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();
}

 

总结：一个好的方法是通过不断的改进优化的，在此感谢常老师对我一些指导。