反射有多慢

Question

我最近创建了一个接口层来区分 DataAccessProvider 和我们的业务逻辑层。 使用这种方法，我们可以随时通过更改 Web/App.Config 中的值来更改对 DataAccessProvider 的选择。 （如果需要可以提供更多细节）。

无论如何，为此我们使用反射来完成我们可以工作的 DataProvider 类。

/// <summary>
/// The constructor will create a new provider with the use of reflection.
/// If the assembly could not be loaded an AssemblyNotFoundException will be thrown.
/// </summary>
public DataAccessProviderFactory()
{
    string providerName = ConfigurationManager.AppSettings["DataProvider"];
    string providerFactoryName = ConfigurationManager.AppSettings["DataProviderFactory"];
    try
    {
        activeProvider = Assembly.Load(providerName);
        activeDataProviderFactory = (IDataProviderFactory)activeProvider.CreateInstance(providerFactoryName);
    }
    catch
    {
        throw new AssemblyNotFoundException();
    }
}

但现在我想知道反射有多慢？

Answer 1

在大多数情况下：足够快。例如，如果您使用它来创建 DAL 包装器对象，与连接到网络所需的时间相比，通过反射创建对象所花费的时间将微不足道。所以优化这将是浪费时间。

如果您在紧密循环中使用反射，有一些技巧可以改进它：

• 泛型（使用包装器 where T : new() 和 MakeGenericType）
• Delegate.CreateDelegate（对类型化委托；不适用于构造函数）
• Reflection.Emit - 铁杆
• Expression（类似于Delegate.CreateDelegate，但更灵活，适用于构造函数）

但出于您的目的，CreateInstance 非常好。坚持下去，让事情变得简单。

---

编辑：虽然关于相对性能的观点仍然存在，虽然最重要的事情“衡量它”仍然存在，但我应该澄清上述一些内容。有时……它确实很重要。先测量。然而，如果你发现它是太慢了，你可能想看看像FastMember这样的东西，它在后台安静地执行所有Reflection.Emit代码，给你一个很好的简单API；例如：

var accessor = TypeAccessor.Create(type);
List<object> results = new List<object>();
foreach(var row in rows) {
    object obj = accessor.CreateNew();
    foreach(var col in cols) {
        accessor[obj, col.Name] = col.Value;
    }
    results.Add(obj);
}

这很简单，但会非常快。在我提到的具体示例中，我提到了一个 DAL 包装器——如果你正在做很多事情，请考虑像 dapper 这样的东西，它再次在后台执行所有 Reflection.Emit 代码，为你提供最快但易于使用的 API：

int id = 12345;
var orders = connection.Query<Order>(
    "select top 10 * from Orders where CustomerId = @id order by Id desc",
    new { id }).ToList();

Answer 2

与非反射代码相比，它的速度较慢。重要的不是它是否缓慢，而是它是否缓慢它很重要。例如，如果您在 Web 环境中使用反射来实例化对象，而预期的并发性可能会上升到 10K，那么它会很慢。

不管怎样，不用提前关心性能是好的。如果事情变得很慢，如果您设计正确，您总是可以加快速度，以便将您预期将来可能需要优化的部分本地化。

如果你需要加快速度，你可以查看这篇著名的文章：

Dynamic... But Fast: The Tale of Three Monkeys, A Wolf and the DynamicMethod and ILGenerator Classes

Answer 3

以下是一些可能有帮助的链接：

• This guy did some tests and provides a few metrics。这篇文章是2006年的，所以我发了Gist of the code to test Reflection Performance。结果是相似的（虽然现在明显快了很多）。

   Constructor
   Time elapsed (ms): 15 which is 151588 ticks for 1000000 calls.
  
   Constructor using reflection
   Time elapsed (ms): 38 which is 381821 ticks for 1000000 calls.
  
   Method call
   Time elapsed (ms): 5 which is 57002 ticks for 1000000 calls.
  
   Method call using reflection
   Time elapsed (ms): 252 which is 2529507 ticks for 1000000 calls.
  
   Setting properties
   Time elapsed (ms): 294 which is 2949458 ticks for 1000000 calls.
  
   Setting properties using reflection
   Time elapsed (ms): 1490 which is 14908530 ticks for 1000000 calls.
  

• MSDN article "Dodge Common Performance Pitfalls to Craft Speedy Applications"

Answer 4

我想我应该做一个快速测试来证明与没有反射相比有多慢。

带反射

• 通过迭代每个属性并匹配来实例化 58 个对象

• 总时间：52254 纳秒

  while (reader.Read()) {
      string[] columns = reader.CurrentRecord;
      CdsRawPayfileEntry toAdd = new CdsRawPayfileEntry();
      IEnumerable<PropertyInfo> rawPayFileAttributes = typeof(CdsRawPayfileEntry).GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(CustomIndexAttribute)));
      foreach (var property in rawPayFileAttributes) {
          int propertyIndex = ((CustomIndexAttribute)property.GetCustomAttribute(typeof(CustomIndexAttribute))).Index;
          if (propertyIndex < columns.Length)
              property.SetValue(toReturn, columns[propertyIndex]);
          else
              break;
      }
  }
  

无反射

• 通过创建新对象实例化 58 个对象

• 总时间：868 纳秒

      while (reader2.Read()) {
          string[] columns = reader2.CurrentRecord;
          CdsRawPayfileEntry toAdd = new CdsRawPayfileEntry() {
              ColumnZero = columns[0],
              ColumnOne = columns[1],
              ColumnTwo = columns[2],
              ColumnThree = columns[3],
              ColumnFour = columns[4],
              ColumnFive = columns[5],
              ColumnSix = columns[6],
              ColumnSeven = columns[7],
              ColumnEight = columns[8],
              ColumnNine = columns[9],
              ColumnTen = columns[10],
              ColumnEleven = columns[11],
              ColumnTwelve = columns[12],
              ColumnThirteen = columns[13],
              ColumnFourteen = columns[14],
              ColumnFifteen = columns[15],
              ColumnSixteen = columns[16],
              ColumnSeventeen = columns[17]
          };
      }
  

虽然不完全公平，因为反射还必须在通过反射创建新对象的基础上检索每个属性的特定属性 58*18 次，但它至少提供了一些视角。

Answer 5

反射并没有那么慢。通过反射调用方法比普通方法慢大约 3 倍。如果您只执行一次或在非关键情况下执行此操作，那没问题。如果您在时间紧迫的方法中使用它 10000 次，我会考虑更改实现。

Answer 6

除了遵循其他答案中给出的链接并确保您没有编写“病态糟糕”的代码之外，对我来说，最好的答案是自己测试。

只有您知道瓶颈在哪里，您的反射代码将被用户使用多少次，反射代码是否会处于紧密循环中等。您知道您的业务案例，有多少用户将访问您的网站，性能如何要求是。

但是，鉴于您在此处显示的代码的 sn-p，那么我的猜测是反射的开销不会是一个大问题。

VS.NET Web 测试和性能测试功能应该使测量此代码的性能变得非常简单。

如果您不使用反射，您的代码会是什么样子？它会有什么限制？如果您删除反射代码，您可能无法忍受自己发现的限制。可能值得尝试在没有反射的情况下设计此代码，以查看它是否可能或替代方案是否可取。

Answer 7

在我开始玩 IoC 之前，我一直在做类似的事情。我会使用 Spring 对象定义来指定数据提供者 - SQL、XML 或 Mocks！