爲什麼鑄造數組（向量）這麼慢？

Question

我的印象是，在.NET鑄造（不轉換）是非常便宜和快速。但是，這似乎並不適用於數組。我想在這裏做一個非常簡單的演員，拍一個T1 []並且投射爲T2 []。其中T1：T2。

有3種方法來做到這一點，我打電話給他們以下::

DropCasting: T2[] array2 = array; 
CastClass: (T2[])array; 
IsInst: array as T2[]; 

我創建的方法來做到這一點，不幸的是，C＃似乎取決於如果這創造一些比較奇怪的代碼是通用還是不通用。 （如果它的泛型DropCasting使用了castclass操作符，並且在兩種情況下都拒絕在T1：T2時發出'as'操作符

無論如何，我寫了一些Dynamic方法，並且測試了一些令人驚訝的結果（string [] =>對象[]）：？

DropCast : 223ms 
IsInst : 3648ms 
CastClass: 3732ms 

Dropcasting比任鑄造運營商的更快〜18倍爲什麼是鑄造這麼慢數組 對於像字符串正常對象=>對象，差異少得多嚴重

DropCast : 386ms 
IsInst : 611ms 
CastClass: 519ms 

基準代碼bel流量：

class Program 
{ 
    static readonly String[] strings = Enumerable.Range(0, 10).Select(x => x.ToString()).ToArray(); 

    static Func<string[], object[]> Dropcast = new Func<Func<string[], object[]>>(
     () => 
     { 
      var method = new DynamicMethod("DropCast", typeof(object[]), new[] { typeof(object), typeof(string[]) },true); 
      var ilgen = method.GetILGenerator(); 
      ilgen.Emit(OpCodes.Ldarg_1); 
      ilgen.Emit(OpCodes.Ret); 
      return method.CreateDelegate(typeof(Func<string[], object[]>)) as Func<string[], object[]>; 
     })(); 
    static Func<string[], object[]> CastClass = new Func<Func<string[], object[]>>(
     () => 
     { 
      var method = new DynamicMethod("CastClass", typeof(object[]), new[] { typeof(object), typeof(string[]) },true); 
      var ilgen = method.GetILGenerator(); 
      ilgen.Emit(OpCodes.Ldarg_1); 
      ilgen.Emit(OpCodes.Castclass, typeof(object[])); 
      ilgen.Emit(OpCodes.Ret); 
      return method.CreateDelegate(typeof(Func<string[], object[]>)) as Func<string[], object[]>; 
     })(); 

    static Func<string[], object[]> IsInst = new Func<Func<string[], object[]>>(
     () => 
     { 
      var method = new DynamicMethod("IsInst", typeof(object[]), new[] { typeof(object), typeof(string[]) },true); 
      var ilgen = method.GetILGenerator(); 
      ilgen.Emit(OpCodes.Ldarg_1); 
      ilgen.Emit(OpCodes.Isinst, typeof(object[])); 
      ilgen.Emit(OpCodes.Ret); 
      return method.CreateDelegate(typeof(Func<string[], object[]>)) as Func<string[], object[]>; 
     })(); 

    static Func<string[], object[]>[] Tests = new Func<string[], object[]>[]{ 
     Dropcast, 
     IsInst, 
     CastClass 
    }; 
    static void Main(string[] args) 
    { 
     int maxMethodLength = Tests.Select(x => GetMethodName(x.Method).Length).Max(); 
     RunTests(1, false, maxMethodLength); 
     RunTests(100000000, true, maxMethodLength); 
    } 

    static string GetMethodName(MethodInfo method) 
    { 
     return method.IsGenericMethod ? 
     string.Format(@"{0}<{1}>", method.Name, string.Join<Type>(",", method.GetGenericArguments())) : method.Name; 
    } 

    static void RunTests(int count, bool displayResults, int maxLength) 
    { 
     foreach (var action in Tests) 
     { 
      Stopwatch sw = Stopwatch.StartNew(); 
      for (int i = 0; i < count; i++) 
      { 
       action(strings); 
      } 
      sw.Stop(); 
      if (displayResults) 
      { 
       Console.WriteLine("{0}: {1}ms", GetMethodName(action.Method).PadRight(maxLength), 
       ((int)sw.ElapsedMilliseconds).ToString().PadLeft(6)); 
      } 
      GC.Collect(); 
      GC.WaitForPendingFinalizers(); 
      GC.Collect(); 
     } 
    } 
} 

人之前編輯問同樣保持真實的東西如int [] - > UINT []該CLR規格應無需轉換投。

Answer 1

因爲您正在投射數組。

的IL代碼的3個片段之間的區別在於後兩種添加Is​​Inst和CastClass操作。對這些類型知之甚少，所以CLR必須檢查它是否是有效的操作。這需要時間。

CastClass和IsInst之間的微小差異可以通過一個事實，即CastClass首先進行零檢查，併成功立即如果參數爲空來解釋。

我懷疑減速是因爲你在數組之間進行轉換。可能需要做更多的工作才能確保數組轉換是有效的。可能需要查看每個元素以查看它是否可以轉換爲目標元素類型。所以我會猜測，JIT不是在'內聯'機器代碼中完成所有這些工作，而是發出對驗證函數的調用。

事實上，如果你運行一個性能分析，可以看到，確實是發生了什麼。幾乎90％的時間花在一個名爲「JIT_ChkCastArray」的函數中。

Answer 2

這是有道理的，我認爲鑄件是（幾乎）完全一樣的使用as操作昂貴。在這兩種情況下，必須對對象類型進行運行時檢查，並且必須確定它是否與目標類型兼容。如果需要，該檢查是允許投射操作投擲InvalidCastException。

換句話說，as運營商是轉換操作 - 它也具有允許轉換失敗而不拋出異常（通過返回null）的優點。這也可以通過組合is運算符和一個演員來完成，但這會使工作量增加一倍。