欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Entity Framework 高性能 泛型缓存+动态Lambda

程序员文章站 2022-04-08 21:32:26
前言:自学CSharp挺长时间的了,这是我第一编博客,跟大家分享一下。如有不足地方请多多包涵,也欢迎大家提出更好的意见,下面开始进入正题。 一、泛型缓存 1.概念:1、泛型(泛型也是一种推断类型,从而实现不同类型可以使用同一个类或者方法、属性,大大的减少代码的冗余) 2、缓存(暂时存储) 2.应用场 ......

前言:自学csharp挺长时间的了,这是我第一编博客,跟大家分享一下。如有不足地方请多多包涵,也欢迎大家提出更好的意见,下面开始进入正题。

一、泛型缓存

1.概念:1、泛型(泛型也是一种推断类型,从而实现不同类型可以使用同一个类或者方法、属性,大大的减少代码的冗余)   2、缓存(暂时存储)

2.应用场景(通俗易懂的理解):场景1、执行同参数的泛型方法时为了提高性能减少对方法体执行的次数,就可以使用泛型缓存之前执行过的返回值。

还有其他应用场景不一 一 举例,需要认真体会。

3.代码执行流程图

Entity Framework 高性能 泛型缓存+动态Lambda

调用缓存方法的截图

Entity Framework 高性能 泛型缓存+动态Lambda

完整的参考代码

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

 

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