public class DataOperateInput<T>
{
    public Func<T> GetDataFromLocalCache { get; set; } = null;        //獲取本地緩存數(shù)據(jù)
    public Func<T> GetDataFromDistributeCache { get; set; } = null;   //獲取分布式緩存數(shù)據(jù)
    public Func<T> GetDataFromDb { get; set; } = null;                //獲取DB數(shù)據(jù)
    public Action<T> SetDataTolocalCache { get; set; } = null;        //設(shè)置本地緩存數(shù)據(jù)
    public Action<T> SetDataToDistributeCache { get; set; } = null;   //設(shè)置分布式緩存數(shù)據(jù)
}

    public class DataOperate
    {
        /// <summary>
        /// 獲取數(shù)據(jù)入口
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="input"></param>
        /// <returns></returns>
        public T GetData<T>(DataOperateInput<T> input) where T : class, new()
        {
            T result = null;

            //需要從本地緩存取
            if (input.GetDataFromLocalCache != null)
            {
                //調(diào)用本地緩存委托方法獲取值
                result = input.GetDataFromLocalCache();

                if (result != null)
                {
                    return result;
                }
            }
            //獲取值為空或者不從本地緩存獲取，調(diào)用下面的方法，從分布式緩存和Db中獲取數(shù)據(jù)
            return GetDataFromDistributeAndDB(input);
        }

        /// <summary>
        /// 從分布式緩存和Db中獲取數(shù)據(jù)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="input"></param>
        /// <returns></returns>
        private T GetDataFromDistributeAndDB<T>(DataOperateInput<T> input) where T : class, new()
        {
            T result = null;

            if (input.GetDataFromDistributeCache != null)
            {
                //從緩存中取值
                result = input.GetDataFromDistributeCache();

                //如果需要設(shè)置會(huì)本地緩存，那么設(shè)置
                if (result != null)
                {
                    //如果設(shè)置本地緩存的委托存在，調(diào)用它設(shè)置本地緩存
                    input.SetDataTolocalCache?.Invoke(result);
                }
            }

            //獲取值為空或者不從分布式緩存獲取，調(diào)用下面的方法，從Db中獲取數(shù)據(jù)
            return GetDataFromDB(input);
        }

        /// <summary>
        /// 從數(shù)據(jù)庫(kù)中獲取數(shù)據(jù)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="input"></param>
        /// <returns></returns>
        private T GetDataFromDB<T>(DataOperateInput<T> input) where T : class, new()
        {
            T result = null;
            if (input.GetDataFromDb != null)
            {
                //從DB中取值
                result = input.GetDataFromDb();

                //如果需要設(shè)置會(huì)分布式緩存和本地緩存，那么設(shè)置
                if (result != null)
                {
                    input.SetDataToDistributeCache?.Invoke(result);
                    input.SetDataTolocalCache?.Invoke(result);
                }
            }
            return result;
        }

    }

/// <summary>
/// 數(shù)據(jù)源類(lèi)別
/// </summary>
[Flags]
public enum DataSourceKind
{
    /// <summary>
    /// 本地緩存
    /// </summary>
    LocalCache = 1,
    /// <summary>
    /// 分布式緩存
    /// </summary>
    DistributeCache = 2,
    /// <summary>
    /// 數(shù)據(jù)庫(kù)
    /// </summary>
    DataBase = 4
}

public class User : IUser
{
    public long UserId { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
    public int Sex { get; set; }
}

    /// <summary>
    /// 獲取用戶(hù)數(shù)據(jù)
    /// </summary>
    /// <param name="userId">用戶(hù)Id（可以是自己相關(guān)的業(yè)務(wù)代碼）</param>
    /// <param name="dataSources">數(shù)據(jù)源類(lèi)型（調(diào)用方可以自己組合）</param>
    /// <param name="needUpdatelocal">是否需要更新本地緩存</param>
    /// <param name="needUpdateDistribute">是否需要更新分布式緩存</param>
    /// <returns></returns>
    public User GetUserInfo(long userId, 
        DataSourceKind dataSources = DataSourceKind.LocalCache , 
        bool needUpdatelocal = false, 
        bool needUpdateDistribute = false)
    {
        Console.WriteLine($"======數(shù)據(jù)源:{dataSources.ToString()} 是否更新本地:{needUpdatelocal}  是否更新Redis:{needUpdateDistribute}======");
   
        //初始化一個(gè)輸入?yún)?shù)類(lèi)
        var input = new DataOperateInput<User>();

        //如果包含從本地緩存取值
        if (dataSources.HasFlag(DataSourceKind.LocalCache))
        {
            input.GetDataFromLocalCache = () =>
            {
                //！！這里可以寫(xiě)具體的 獲取本地緩存的處理邏輯
                return GetUserFromLocalCache(userId);
            };
        }

        //如果包含從分布式緩存取值
        if (dataSources.HasFlag(DataSourceKind.DistributeCache))
        {
            input.GetDataFromDistributeCache = () =>
            {       
                //！！這里可以寫(xiě)具體的獲取分布式緩存的處理邏輯
                return GetUserFromRedisCache(userId);
            };

            if (needUpdatelocal)
            {
                input.SetDataTolocalCache = (value) =>
                {
                    //?。∵@里可以寫(xiě)具體的設(shè)定本地緩存的處理邏輯
                    SetUserToLocalCache(value);
                };
            }
        }

        //如果包含從數(shù)據(jù)庫(kù)緩存取值
        if (dataSources.HasFlag(DataSourceKind.DataBase))
        {
            input.GetDataFromDb = () =>
            {
                //?。∵@里可以寫(xiě)具體的獲取數(shù)據(jù)庫(kù)數(shù)據(jù)的處理邏輯
                return GetUserFromDB(userId);
            };

            if (needUpdateDistribute)
            {
                //??！這里可以寫(xiě)具體的設(shè)定分布式緩存的處理邏輯
                input.SetDataToDistributeCache = (value) =>
                {
                    SetUserToRedisCache(value);
                };
            }

            if (needUpdatelocal)
            {
                //！！這里可以寫(xiě)具體的設(shè)定本地緩存的處理邏輯
                input.SetDataTolocalCache = (value) =>
                {
                    SetUserToLocalCache(value);
                };
            }
        }

        //執(zhí)行我們組合好的input
        var result =  new DataOperate().GetData(input);

        Console.WriteLine("=============================================\n");

        return result;
    }

/// <summary>
/// 從本地緩存獲取用戶(hù)信息
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
private User GetUserFromLocalCache(long userId)
{
    User user = null;

    if (userId == 1 )
    {
        user = new User
        {
            UserId = userId,
            Age = 10,
            Name = $"BigOrange_{userId}",
            Sex = 1
        };
    }

    if (user == null)
    {
        Console.WriteLine($"從本地緩存取值 未查詢(xún)到  UserId={userId}");
    }
    else
    {
        Console.WriteLine($"從本地緩存取值  UserId={user.UserId} Name={user.Name} ");
    }
    
    return user;
}

/// <summary>
/// 從Redis緩存獲取用戶(hù)信息
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
private User GetUserFromRedisCache(long userId )
{
    User user = null;
    
    if (userId == 1 || userId == 2 )
    {
        user =  new User
        {
            UserId = userId,
            Age = 10,
            Name = $"BigOrange_{userId}",
            Sex = 1
        };
    }

    if (user == null)
    {
        Console.WriteLine($"從Redis緩存取值 未查詢(xún)到  UserId={userId}");
    }
    else
    {
        Console.WriteLine($"從Redis緩存取值 UserId={user.UserId} Name={user.Name}");
    }

    return user;
}

/// <summary>
/// 從DB獲取用戶(hù)信息
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
private User GetUserFromDB(long userId)
{
    Console.WriteLine("從數(shù)據(jù)庫(kù)中取值");

    User user = null;

    if (userId == 1 || userId == 2 || userId == 3)
    {
        user = new User
        {
            UserId = userId,
            Age = 10,
            Name = $"BigOrange_{userId}",
            Sex = 1
        };
    }

    if (user == null)
    {
        Console.WriteLine($"從DB取值 未查詢(xún)到  UserId={userId}");
    }
    else
    {
        Console.WriteLine($"從DB取值 UserId={user.UserId} Name={user.Name}");
    }


    return user;
}

/// <summary>
/// 設(shè)置用戶(hù)信息到本地緩存
/// </summary>
/// <param name="userInfo"></param>
/// <returns></returns>
private bool SetUserToLocalCache(User userInfo)
{
    Console.WriteLine($"設(shè)置值到本地緩存:useId = {userInfo.UserId}");
    return true;
}

/// <summary>
/// 設(shè)置用戶(hù)信息到Redis緩存
/// </summary>
/// <param name="userInfo"></param>
/// <returns></returns>
private bool SetUserToRedisCache(User userInfo)
{
    Console.WriteLine($"設(shè)置值到Redis緩存:useId = {userInfo.UserId}");
    return true;
}

static void Main(string[] args)
{
    var userInfoService = new UserInfoService();

    /*
     * 測(cè)試用例 
       數(shù)據(jù)庫(kù)中存在 User1、User2、User3 
       分布式緩存 User1、User2
       本地緩存 User1
     */

    //1.只從本地緩存取值
    userInfoService.GetUserInfo(1, DataSourceKind.LocalCache);  
    userInfoService.GetUserInfo(2, DataSourceKind.LocalCache); 

    //2.只從Redis緩存取值
    userInfoService.GetUserInfo(2, DataSourceKind.DistributeCache);  
    userInfoService.GetUserInfo(3, DataSourceKind.DistributeCache);  

    //3.只從DB取值
    userInfoService.GetUserInfo(3, DataSourceKind.DataBase); 
    userInfoService.GetUserInfo(4, DataSourceKind.DataBase); 

    //4.從本地緩存和Redis取值
    userInfoService.GetUserInfo(1, DataSourceKind.LocalCache | DataSourceKind.DistributeCache);
    //不更新到本地
    userInfoService.GetUserInfo(2, DataSourceKind.LocalCache | DataSourceKind.DistributeCache, false);
    //更新到本地
    userInfoService.GetUserInfo(2, DataSourceKind.LocalCache | DataSourceKind.DistributeCache, true);

    //5.從Redis和DB取值
    userInfoService.GetUserInfo(2, DataSourceKind.DistributeCache | DataSourceKind.DataBase);
    userInfoService.GetUserInfo(3, DataSourceKind.DistributeCache | DataSourceKind.DataBase, false, false);
    userInfoService.GetUserInfo(3, DataSourceKind.DistributeCache | DataSourceKind.DataBase, false, true);

    //6.從本地和DB取值
    userInfoService.GetUserInfo(1, DataSourceKind.LocalCache | DataSourceKind.DataBase);
    userInfoService.GetUserInfo(3, DataSourceKind.LocalCache | DataSourceKind.DataBase, false,false);
    userInfoService.GetUserInfo(3, DataSourceKind.LocalCache | DataSourceKind.DataBase, true, false);

    //7.三者都使用
    userInfoService.GetUserInfo(1, DataSourceKind.LocalCache | DataSourceKind.DistributeCache | DataSourceKind.DataBase,false,false);
    userInfoService.GetUserInfo(2, DataSourceKind.LocalCache | DataSourceKind.DistributeCache | DataSourceKind.DataBase,false,false);
    userInfoService.GetUserInfo(2, DataSourceKind.LocalCache | DataSourceKind.DistributeCache | DataSourceKind.DataBase, true,false);
    userInfoService.GetUserInfo(3, DataSourceKind.LocalCache | DataSourceKind.DistributeCache | DataSourceKind.DataBase,false,false);
    userInfoService.GetUserInfo(3, DataSourceKind.LocalCache | DataSourceKind.DistributeCache | DataSourceKind.DataBase, true, false);
    userInfoService.GetUserInfo(3, DataSourceKind.LocalCache | DataSourceKind.DistributeCache | DataSourceKind.DataBase, false, true);
    userInfoService.GetUserInfo(3, DataSourceKind.LocalCache | DataSourceKind.DistributeCache | DataSourceKind.DataBase, true,true);

    Console.ReadKey();
}