C# 反射优化

于 2024-07-30 18:57:44 发布
阅读量761 收藏 12
点赞数 13
分类专栏： # 技术进阶 文章标签： c# 开发语言 .net 性能优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/UnityBoy/article/details/140800063
版权

概述

反射是 Microsoft .NET 框架中非常强大的功能之一。除了在运行时动态检索元数据信息（如方法、属性和特性）外，它还在命名空间 System.Reflection 下提供了一套丰富的 API，用于加载和处理程序集和对象。

使用反射确实使开发人员的工作变得简单，但应尽量少用，换句话说，只有在需要时才使用，否则会在很大程度上影响性能。有不同的技术可以帮助高效地使用反射。

很多时候，我们在使用反射时并没有意识到它所带来的代价。本文将介绍一些优化使用反射的技术。

解决方案

本文将讨论一些完全避免使用反射或至少避免重复调用反射的技巧。我们将探讨一些可以有效使用反射的场景。

场景1 - 动态调用方法

如果在运行时创建的对象上要调用的方法/成员的名称在开发时是已知的，那么不要使用反射来动态调用它们，而是使用接口并静态调用它们。

完全动态调用的示例

public void DynamicExecution()
{
    Type objType = Type.GetType("DynamicExecution.Test.DynamicClass");

    object obj = Activator.CreateInstance(objType);
    MethodInfo mInfo = objType.GetMethod("AddNumbers",
	new Type[] { typeof(int), typeof(int) });

    // 在 obj 上动态执行 AddNumbers 方法
    mInfo.Invoke(obj, new object[] { 1, 5 });

    PropertyInfo pInfo = objType.GetProperty("ID");

    // 在 obj 上动态设置 ID 属性
    pInfo.SetValue(obj, "TEST_ID", null );
}

使用上述代码的缺点是： 

  1. 对方法或属性的每次动态调用都比对同一方法或属性的静态调用开销几倍。
  2. 在编译期间不会检查方法参数和属性值的类型安全性，如果提供的参数类型不合适，则代码可能会在运行时中断。
  3. 代码比优化的代码更长，因此可维护性较差。

优化代码示例

Public void OptimizedDynamicExecution()
{
    Type objType = Type.GetType("DynamicExecution.Test.DynamicClass");

    IDynamicClass obj = Activator.CreateInstance(objType) as IDynamicClass;

    if (null != obj)
    {
        // 在 obj 上静态执行 AddNumbers 方法
        int result = obj.AddNumbers(1, 5);

        // 在 obj 上静态设置 ID 属性
	// The code will not compile if value is assigned as "TEST_ID"
        obj.ID = 10; 
    }
}

// 优化动态执行 API 使用的接口
public interface IDynamicClass
{
    int ID { get; set; }

    int AddNumbers(int a, int b);
}

使用上述代码的好处是： 

  1. 由于该方法是静态执行的，因此执行速度快。
  2. 通过使用接口实现类型安全。
  3. 可以根据需要在其他地方使用相同的接口。
  4. 用于进行方法调用等的较短代码。

场景2 - 从类中读取自定义属性

自定义特性(Attributes)用于提供有关程序集、类或类成员的附加信息，因此，如果一个类修饰了每次创建该类的实例时都需要的特性，则建议将该值缓存在静态变量中，以便反射仅用于第一个实例，并且可以避免用于后续实例。

下面是一个实体类的示例：

[Table(Name="Employees")]
public class Employee : Entity
{
    [PrimaryKey]
    public int Id { get; set; }
    
    public string Name { get; set; }
    public string Address { get; set; }
    public DateTime DOB { get; set; }
}

上面的代码是一个实体类的示例，它对应于数据库中名为“Employees”的表。如果您仔细观察它，属性Id被PrimaryKey特性标记。所有成员，包括类本身，都用属性装饰，都具有一些特殊的含义，这是此类的使用者在处理其每个实例时所必需的。

为了检索此信息，我们必须应用反射来读取此类的特性（Attributes）。如果对此类的每个实例重复此操作，则成本将非常高。从性能的角度来看，一个更好的想法是仅在第一次读取它，并为所有后续实例缓存它。

动态检索每个实例的属性信息的示例

public class Entity
{
    public Entity()
    {
        Type curType = this.GetType();

        // 以下反射代码在创建此类的每个实例时都会被执行。
        object[] tableAttributes =
		curType.GetCustomAttributes(typeof(TableAttribute), true);

        if(null != tableAttributes && tableAttributes.Count() > 0)
        {
            // 读取特性(attribute)信息
        }

        // 在这里使用特性(attribute)信息
    }
}

使用上述代码的缺点是

  1. 每次创建此类的对象时，都会使用反射动态检索属性信息。
  2. 使用反射检索属性信息是一项非常昂贵的操作。

以下示例演示了缓存属性信息以实现更好性能的概念：

// 用于保存表信息的结构
public struct TableInfo
{
    public string TableName;
    public string PrimaryKey;
}

在下面的此示例代码中，构造函数使用当前实体类的类型作为键来查找静态字典对象中是否存在表信息。它不会在第一次被发现，这时将使用反射检索属性信息，并保留在集合中以供后续检索。这就是我们节省反射成本的方式。

public class Entity
{
    private static Dictionary<Type, TableInfo> tableInfoList = 
                                         new Dictionary<Type, TableInfo>();

    public Entity()
    {
        Type curType = this.GetType();
        TableInfo curTableInfo;
        
        if (!tableInfoList.TryGetValue(curType, out curTableInfo))
        {
            lock (this)
            {
                // 仔细检查以确保在this锁之前没有创建实例
                if (!tableInfoList.TryGetValue(curType, out curTableInfo))
                {
                    object[] tableAttributes = curType.GetCustomAttributes(typeof(TableAttribute), true);

                    if(null != tableAttributes && tableAttributes.Count() > 0)
                    {
                        curTableInfo = new TableInfo();
                        curTableInfo.TableName = ((TableAttribute) tableAttributes[0]).Name;
                    }
                }
            }
        }

        // 在这里使用 curTableInfo 
    }
}

上面的示例代码演示了如何从自定义属性中检索一次信息，并将其用于同一类的后续实例，而无需每次都运行反射代码。

使用此技术的好处是：

  1. 反射仅在第一次应用，并且所有后续时间都使用信息的缓存副本。
  2. 通过使用缓存技术，可以最大限度地降低反射成本。

场景3 - 依赖注入

很多时候，我们需要在一些代码片段中注入依赖项，以便将特定功能的实现逻辑与其消费者的逻辑解耦，以便实现可以在以后的时间点由不同的提供者提供。为了处理这种情况，我们通常允许用户在配置文件中配置程序集和要注入的类。

在这种情况下，应用程序将需要加载程序集，并在每次需要时使用反射动态创建依赖项类的实例;就处理而言，此操作非常昂贵，并且在应用程序的这一部分流量过大的情况下，将导致性能不佳。

Microsoft .NET 轻量级代码生成有助于解决在设计时创建未知的任何对象的实例的问题。它在System.Reflection.Emit命名空间下提供了一组 API，用于以编程方式创建程序集、类和方法等。

此技术可用于减少每次使用反射创建对象的开销，方法是创建静态创建所需类的实例的动态方法。然后，可以将此方法的委托缓存在字典中，以便后续调用。

以下示例演示了此概念 

public interface ISecurityProvider
{
    bool ValidateUser(string userId, string password);
    List<User> GetUsersList();
}

public interface DefaultSecurityProvider : ISecurityProvider
{
    public bool ValidateUser(string userId, string password)
    {
        ...
    }
    public List<User> GetUsersIist()
    {
        ...
    }
}

完全动态调用的示例

// 动态创建 DefaultSecuirtyProvider 类实例的方法
private void CreateInstance()
{
    Type classType = Type.GetType("DefaultSecurityProvider, AssemblyName");
    
    // 以下代码每次都使用反射动态创建依赖类的实例。
    ISecurityProvider employeeInstance = Activator.CreateInstance(classType) as ISecurityProvider;
}

使用上述代码的缺点是： 

  1. 每次需要依赖类的实例时，都将使用反射动态创建该实例。
  2. 使用反射动态创建对象是一项非常昂贵的操作。

以下代码演示了如何避免反射成本： 

// 动态创建 DefaultSecuirtyProvider 类实例的方法
private void CreateInstance()
{
    Type classType = Type.GetType("DefaultSecurityProvider, AssemblyName");

    // 以下函数静态地返回用于实例化所需对象的委托。
    CreateInstanceDelegate createInstance = ObjectInstantiater(classType);

    // 执行用于创建依赖类实例的委托
    ISecurityProvider employeeInstance = createInstance() as ISecurityProvider;
}

以下委托将用于映射使用 Microsoft .NET 轻量级代码生成技术动态创建的方法 

// 用于保存对象实例化器方法的委托
public delegate object CreateInstanceDelegate();

以下字典对象将保存动态创建的方法的代表，这些方法是为了实例化依赖类对象

// 用于保存对象实例化委托的字典
private static Dictionary<Type, CreateInstanceDelegate> _createInstanceDelegateList = new Dictionary<Type, CreateInstanceDelegate>();

以下函数在运行时以编程方式创建一个方法，用于实例化给定类型的对象。

// 动态创建给定类型实例的方法
public static CreateInstanceDelegate ObjectInstantiater(Type objectType)
{
    CreateInstanceDelegate createInstanceDelegate;

    if (!_createInstanceDelegateList.TryGetValue(objectType, out createInstanceDelegate))
    {
        lock (objectType)
        {
            if (!_createInstanceDelegateList.TryGetValue(objectType, out createInstanceDelegate))
            {
                // 创建一个新方法        
                DynamicMethod dynamicMethod = new DynamicMethod("Create_" + objectType.Name, objectType, new Type[0]);

                // 获取插入类型的默认构造函数
                ConstructorInfo ctor = objectType.GetConstructor(new Type[0]);

                // 生成中间语言      
                ILGenerator ilgen = dynamicMethod.GetILGenerator();
                ilgen.Emit(OpCodes.Newobj, ctor);
                ilgen.Emit(OpCodes.Ret);

                // 创建一个新委托并存储到字典中
                createInstanceDelegate = (CreateInstanceDelegate)dynamicMethod.CreateDelegate(typeof(CreateInstanceDelegate));
                _createInstanceDelegateList[objectType] = createInstanceDelegate;
            }
        }
    }
    return createInstanceDelegate; // 返回对象实例化器委托
}

上面的代码演示了如何静态创建任何类的对象，该对象在设计时是未知的，只能由其接口（合约）识别。

在上面的示例中，我们使用System.Reflection.Emit命名空间中提供的 API 动态创建了一个代理方法，该 API 静态创建依赖项类的实例。一旦创建了这个方法，我们就把它存储在字典中，而不是依赖类的类型作为键，这样在以后的所有时间里，我们都可以从字典中提取这个委托并使用它。

使用此技术的好处是：

  1. 依赖项类的对象是使用Object实例化方法静态创建的。
  2. 这种技术有助于避免对象实例化的反射。

场景4 - 动态设置ORM实体的属性

在所有 ORM 框架中，都有与数据库中的表相对应的实体类。该框架应用反射来读取属性（列）的值，并从实体类的每个实例设置属性（列）的值。这种操作非常昂贵，并且可能会在很大程度上降低性能。这可以通过以与方案 3 中演示的相同方式生成动态方法来处理，但在此示例中，我们将使用 .NET Framework 3.5 中引入的称为表达式树的新功能来实现此目的。

以下示例演示了此概念 

// Employees实体类
public class Employees
{
    public int EmployeeID { get; set; }
    public string LastName { get; set; }
    public string FirstName { get; set; }
    public DateTime BirthDate { get; set; }
}

// Employees列表用于从数据读取器中检索数据进行填充
List<Employees> empList = new List<Employees>();

以下代码填充数据读取器中的Employees列表

List<Employees> empList = new List<Employees>();

using(SqlConnection con = new SqlConnection(@"Data Source=localhost\SQLEXPRESS;
   Initial Catalog=Northwind;Integrated Security=True"))
{
    SqlCommand cmd = new SqlCommand("Select * from employees");
    cmd.Connection = con;
    con.Open();

    using (SqlDataReader reader = cmd.ExecuteReader())
    {
        empList = ReadList<Employees>(reader);
    }
}

使用反射动态设置实体类的属性值的示例

public List<T> ReadList<T>(SqlDataReader reader) where T : new()
{
    var list = new List<T>();

    while (reader.Read())
    {
        T entity = new T();
        Type entityType = typeof(T);
        foreach(var entityProperty in entityType.GetProperties())
        {
            entityProperty.SetValue(entity, reader[entityProperty.Name], null);
        }

        list.Add(entity);
    }
    return list;
}

使用上述代码的缺点是：

  1. 使用反射设置对象的属性是一项非常繁重的操作。
  2. 开发商在设定房产价值时必须注意类型安全

下面的示例演示了如何从实体的SqlDataReader对象中读取值并将其添加到实体列表中，而无需编写事件静态代码，也无需重复应用反射。

Following 函数循环访问数据读取器，并使用相关值填充实体列表

public List<T> ReadList<T>(SqlDataReader reader)
{
    var list = new List<T>();  
    Func<SqlDataReader, T> readRow = GetReader<T>(); 

    while (reader.Read())
    {
        list.Add(readRow(reader));
    }
    return list;
}

以下字典包含动态生成的方法的委托，用于将数据表值填充到实体列表中 

ConcurrentDictionary<Type, Delegate> ExpressionCache = new ConcurrentDictionary<Type, Delegate>();

以下方法使用 Microsoft .NET 的表达式树功能以编程方式创建函数。动态生成的函数将作为委托保存在字典中，以便以后检索

// 动态创建实体属性
public Func<SqlDataReader, T> GetReader<T>()
{
    Delegate resDelegate;
    if (!ExpressionCache.TryGetValue(typeof(T), out resDelegate))
    {
        // 获取 SqlDataReader 的索引器属性 
        var indexerProperty = typeof(SqlDataReader).GetProperty("Item", new[] { typeof(string) });
        var statements = new List<Expression>();
        ParameterExpression instanceParam = Expression.Variable(typeof(T));
        ParameterExpression readerParam = Expression.Parameter(typeof(SqlDataReader));

        BinaryExpression createInstance = Expression.Assign(instanceParam, Expression.New(typeof(T)));
        statements.Add(createInstance);

        foreach (var property in typeof(T).GetProperties())
        {
            MemberExpression getProperty = Expression.Property(instanceParam, property);
            IndexExpression readValue =
                Expression.MakeIndex(readerParam, indexerProperty,
                new[] { Expression.Constant(property.Name) });

            BinaryExpression assignProperty = Expression.Assign(getProperty, Expression.Convert(readValue, property.PropertyType));

            statements.Add(assignProperty);
        }
        var returnStatement = instanceParam;
        statements.Add(returnStatement);

        var body = Expression.Block(instanceParam.Type,
            new[] { instanceParam }, statements.ToArray());

        var lambda = Expression.Lambda<Func<SqlDataReader, T>>(body, readerParam);
        resDelegate = lambda.Compile();

        ExpressionCache[typeof(T)] = resDelegate;
    }
    return (Func<SqlDataReader, T>)resDelegate;
}

在上面的代码中，我们使用 .NET 表达式树功能动态创建了一个函数，该函数在从作为参数传递给它的SqlDataReader对象中读取实体对象的值后设置它们的值。此方法被编译并缓存在字典中，以便可以在所有后续时间使用它，而无需重新创建它。

使用此技术的好处是：

  1. 开发人员无需编写用于设置任何实体值的代码。
  2. 为该方法创建的表达式树可以序列化并跨进程边界传输。
  3. 使用 .NET API 创建表达式树比编写 IL 代码更容易。

结论

我们研究了四种使用场景，在这些场景中，反射技术以不适当的方式使用，导致性能不佳，我们还研究了可以通过使用反射的替代方案或使用缓存机制来避免重复使用反射来提高性能的技术。

本文中使用的缓存技术可确保仅使用反射检索一次信息，并多次使用。

使用轻量级代码生成技术和表达式树的动态代码生成有助于创建静态代理方法，以避免在实例化对象和设置/获取属性值等场景中的反射。

Unity打怪升级
关注
专栏目录
C#反射优化
jcylele的博客
03-20 749
参考博文 用lambda表达式树替代反射 用Emit技术替代反射 未参考博文 C# 之 反射性能优化1 及后续文章 核心代码 采用表达式，比较简洁清晰，博文也说性能和emit差不多 根据条件不初始化PropertyGetter/PropertySetter，耗时会少很多 public class Property { private readonly Pro...
设计模式之抽象工厂+反射(C#版）
jmelzc的博客
03-05 590
设计模式之抽象工厂+反射简介假设有个项目经理总结 简介 在之前的简单工厂里面有两个问题，第一个是switch case的使用会使代码随着类的增多而增多，不便于后面的维护（试想你看着代码里面，一堆的case…），第二个问题是，工厂返回的是指定的类，返回指定类为什么不太友好呢？因为这就相当于，我需要知道你是谁才知道你能干什么（如果现在还不懂什么意思的话，不要着急哈，后面看了我代码的实现就知道了）。 假...
.NET/C# 反射的的性能数据，以及高性能开发建议（反射获取 Attribute 和反射调用方法）
坚定的走
11-11 5957
https://blog.csdn.net/WPwalter/article/details/83744781 大家都说反射耗性能，但是到底有多耗性能，哪些反射方法更耗性能；这些问题却没有统一的描述。 本文将用数据说明反射各个方法和替代方法的性能差异，并提供一些反射代码的编写建议。为了解决反射的性能问题，你可以遵循本文采用的各种方案。 本文内容 反射各方法的性能数据 反射的高性能开发建议 创...
C# 之 反射性能优化1
weixin_34356138的博客
08-16 414
　　反射是一种很重要的技术，然而它与直接调用相比性能要慢很多，因此如何优化反射性能也就成为一个不得不面对的问题。 目前最常见的优化反射性能的方法就是采用委托：用委托的方式调用需要反射调用的方法（或者属性、字段）。 　　目前最常见也就是二种方法：Emit, ExpressionTree 。其中ExpressionTree可认为是Emit方法的简化版本， 所以Emit是最根本的方法，它采用在运行时动...
C# 之 反射性能优化2
weixin_34297300的博客
08-16 195
问题回顾 　　在上篇博客中，我介绍了优化反射的第一个步骤：用委托调用代替直接反射调用。 　　然而，那只是反射优化过程的开始，因为新的问题出现了：如何保存大量的委托？ 　　如果我们将委托保存在字典集合中，会发现这种设计会浪费较多的执行时间，因为这种设计会引发三个新问题： 　　1. 代码的执行路径变长了。 　　2. 字典查找是有成本开销的。 　　3. 字典集合的并发读写需要锁定，会影响并发性。 ...
C# 反射性能优化
xdedzl的博客
11-03 2325
之前在做消息的自动注册机时，发现用反射获到的MethodInfo也是可以转成委托的，于是抽空整理了一下，写了一些用于优化反射的工具类和方法。
C# 之 反射性能优化3
weixin_34400525的博客
08-16 561
阅读目录 开始 用Delegate优化反射的缺点 用Delegate优化反射的优点 用CodeDOM优化反射的优点 如何用好CodeDOM？ 用CodeDOM优化反射的缺点 能不能不使用委托？ 根据反射密集程度选择优化方法 CodeDOM优化的误区 反射优化的总结 在前二篇博客中，我分别介绍了二种优化反射的方法： 1. Delegate：委托。 2. Co...
c#使用dynamic类型优化反射的方法
12-31
什么是dynamic类型? 微软给出的官方文档中这样解释：在通过 dynamic 类型实现的操作中，该类型的作用是绕过编译时类型检查。 改为在运行时解析这些操作。...在大多数情况下，dynamic 类型与 object 类型的行为类似。...
C#之反射优化
Arsin_的博客
03-11 740
1.什么是反射 菜鸟教程上说，反射指程序可以访问、检测和修改它本身状态或行为的一种能力。我的理解就是，反射就是指可以把字符串作为参数去调用方法的一种能力。 如果把“直接调用某个类型的某个方法”比作是齿轮的工作原理，是一个齿轮直接接触带动另一个齿轮工作的，那么“反射调用某个类型的某个方法”就好像是B超的工作原理，是通过发出超声波并解析反射波来解读物体内部结构的。 我们来举个例子： publi...
提升反射的性能（有用，启发）
05-14
你还在为大量使用反射导致性能下降而郁闷吗？你还在为性能考虑而不得不无奈的放弃灵活的反射吗？下了这个库之后，你就不需要担心这些问题了！原来反射也是快速的！
C# 性能分析 反射 VS 配置文件 VS 预编译
10-15
本文分析在 C# 中使用反射和配置文件和预编译做注入的性能，这是本文的测试程序
C#反射性能优化--上篇
baidu_38845827的博客
07-25 420
前两天看到一篇说Automapper为什么比用反射快的文章，觉得挺有意思，反射的性能低老早就知道，但是一直没上手测过，对于反射性能优化也不知道。今天也没什么事情，想到这个让我好奇心按捺不住了，今天就写个测试一下。 目标 使用反射和Automapper组件分别实现 将对象转换成另一个对象 创建两个类 public class PersonSource { public string Name { get; set; } public int Age { get;
C#中使用反射的性能分析-zz
Piggy and Jery 's GOLB
10-22 1259
 最近在研究一个可配置系统的框架，在代码中大量使用了反射的方法，虽然借鉴到其他的语言，如java中反射性能都比较差，但是想到c#既然是一种强类型的语言，对于AppDomain中的类的调用应该性能不会差很多。今天在mvp站点上看到有人说反射的性能很差，要避免使用，就写了一个简单的例子测试了一下测试类如下：namespace ReflectionTest.Test{    public class C
C#反射，性能优化，不止于优化
dotNET跨平台
09-05 1785
“架构师的价值，在于独立且理性的思考”想要写出灵活而且具有更好适应性的代码，反射是首选方案。反射赋予程序在运行时动态创建实例的能力，可以在程序运行时（而非编译时）获取实例类型，获取元数据信息，动态调用实例方法及属性，实现在通常编程逻辑中无法完成的功能，是编程体系中的高阶技能。反射的一大弊端是性能偏低，但反射性能究竟低多少，想必并非每个开发人员都了解，那么本着严谨求实的精神，我们来分析一下反射的执...
C# 反射性能优化C#
qq_32109957的博客
02-05 492
代码可以直接拿来用参考文章：https://www.cnblogs.com/xinaixia/p/5777886.html class Program { static void Main(string[] args) { ReflectionExample(10000); DelegateExample(10000); DelgateCacheExample(10000); Console.ReadKey()..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Unity打怪升级

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值