Entity Framework 高性能 泛型緩存+動態Lambda

前言：自學CSharp挺長時間的了，這是我第一編博客，跟大家分享一下。如有不足地方請多多包涵，也歡迎大家提出更好的意見，下麵開始進入正題。

一、泛型緩存

1.概念：1、泛型(泛型也是一種推斷類型，從而實現不同類型可以使用同一個類或者方法、屬性，大大的減少代碼的冗餘)   2、緩存（暫時存儲）

2.應用場景（通俗易懂的理解）：場景1、執行同參數的泛型方法時為了提高性能減少對方法體執行的次數，就可以使用泛型緩存之前執行過的返回值。

還有其他應用場景不一 一 舉例，需要認真體會。

3.代碼執行流程圖

調用緩存方法的截圖

完整的參考代碼

/// <summary>
/// Lambda緩存
/// </summary>
/// <typeparam name="TSource">源類型</typeparam>
/// <typeparam name="TParameters">參數類型</typeparam>
public class LambdaCache<TSource, TParameters> where TSource : class where TParameters : class
{

private static Dictionary<string, Func<TSource, bool>> MapLambda { get; set; }

private static int CaceCount { get; set; }

static LambdaCache()
{
MapLambda = new Dictionary<string, Func<TSource, bool>>();
CaceCount = 20;
}

/// <summary>
/// 獲取緩存動態Lambda
/// </summary>
/// <param name="parameters">參數對象</param>
/// <returns></returns>
public static Func<TSource, bool> GetDynamicLambda(TParameters parameters)
{
string key = string.Empty;
Dictionary<string, string> keyValues = GetPropertiesValue(parameters, out key);
if (!MapLambda.ContainsKey(key))
{
if (MapLambda.Count == CaceCount)
{
MapLambda.Clear();
}
MapLambda.Add(key, ExpressionExt.DynamicLambda<TSource>(keyValues));
}
return MapLambda[key];
}

/// <summary>
/// 獲取對象屬性值
/// </summary>
/// <param name="obj">對象</param>
/// <returns></returns>
private static Dictionary<string, string> GetPropertiesValue(object obj, out string key)
{
PropertyInfo[] properties = obj.GetType().GetProperties();
Dictionary<string, string> keyValues = new Dictionary<string, string>();
string value = string.Empty;
foreach (var item in properties)
{
var data = item?.GetValue(obj, null);
if (data is DateTime == false && !string.IsNullOrEmpty(data?.ToString()))
{
keyValues.Add(item.Name, data.ToString());
value += data;
}
}
if (string.IsNullOrEmpty(value))
{
value = obj.GetType().Name;//如果不選擇任何條件則值為Null 考慮到參數實體名稱不一致所以直接初始化為實體名稱
}
key = value;
return keyValues;
}
}

/// <summary>
/// 動態Lambda
/// </summary>
/// <typeparam name="TSource">源類型</typeparam>
/// <param name="keyValues">參數鍵值對</param>
/// <returns></returns>
public static Func<TSource, bool> DynamicLambda<TSource>(Dictionary<string, string> keyValues)
{

//定義Lambda參數，列如常寫的“x=>”
ParameterExpression parameter = Expression.Parameter(typeof(TSource), "x");

List<Expression> expressions = new List<Expression>();

foreach (var item in keyValues)
{
//定義lamada的屬性成員
MemberExpression member = Expression.PropertyOrField(parameter, item.Key);
//定義篩選的操作
Expression expression = Expression.Equal(member, Expression.Constant(item.Value, member.Type));
expressions.Add(expression);
}

if (expressions.Count == 0)
{
return (TSource t1) => { return true; };//構造委托Lambda
}

Expression whereExpression = null;
//通過迴圈拼接 Lambda 完整表達式
foreach (var item in expressions)
{
if (whereExpression == null)
{
whereExpression = item;
}
else
{
whereExpression = Expression.And(whereExpression, item);
}
}
return Expression.Lambda<Func<TSource, bool>>(whereExpression, parameter).Compile();
}

總結：一個好的方法是通過不斷的改進優化的，在此感謝常老師對我一些指導。