Разница в производительности в пустой инициализации

Question

массива В последнее время я работал в оптимизации производительности/памяти и stucked в пустой инициализации массива, который использует универсальный метод для инициализации пустого массива:

выполнение кода родового пустого класса массива :

public static class EmptyArray<T> 
    { 
     public static readonly T[] Instance; 

     static EmptyArray() 
     { 
      Instance = new T[0]; 
     } 
    } 

Таким образом, всякий раз, когда создание пустого массива любого типа, он был назван так, как:

var emptyStringArray = EmptyArray<string>.Instance; 

Такое объявление пустого массива было сделано во многих местах кодовой базы. Я смущен, как бы это отличается в производительности при использовании:

var emptyStringArray = new string[0]; 

Я попросил кода выше автора, и он ответил мне:

В основном, все пустые массивы предназначены только для чтения, и равным одному другому, что означает, что вы можете использовать тот же экземпляр (который будет , созданный лениво по требованию во время выполнения) ... Это должно уменьшить общее количество распределений, уменьшить использование памяти и давление в ГК, а должно приводят к некоторому улучшению

Тем не менее, я не могу понять, как бы EmptyArrayInstance повысить производительность в объявлении массива.

Есть ли разница в производительности в коде, используя следующий подход:

1-й подход:

var emptyStrArr = EmptyArray<string>.Instance; 
var emptyFooArr = EmptyArray<Foo>.Instance; 
var emptyBarArr = EmptyArray<Bar>.Instance; 

2-й подход:

var emptyStrArr = new string[0]; 
var emptyFooArr = new Foo[0]; 
var emptyBarArr = new Bar[0]; 

Answer 1

В первом коде в static конструктор выполняется только один раз. Так вы просто создаете на e и использовать его все время. Во втором коде вы каждый раз создаете экземпляр массива. В этом разница.

Вы можете увидеть его более Клири, изменяя конструктор:

static EmptyArray() 
{ 
    Instance = new T[0]; 
    Console.WriteLine("Array of "+ typeof(T) + " is created."); 
} 

var s = EmptyArray<string>.Instance; 
s = EmptyArray<string>.Instance; 
s = EmptyArray<string>.Instance; 

var i = EmptyArray<int>.Instance; 
i = EmptyArray<int>.Instance; 

// output: 
// Array of System.String is created. 
// Array of System.Int32 is created. 

Answer 2

Это:

var emptyStringArray = new string[0]; 

Создает новый экземпляр пустого массива строк каждый раз, когда его называют, со всей соответствующей памятью а это:

public static class EmptyArray<T> 
    { 
     public static readonly T[] Instance; 

     static EmptyArray() 
     { 
      Instance = new T[0]; 
     } 
    } 

Только когда-либо создаётся один экземпляр из пустого массива строк, независимо от того, сколько раз вы вызываете поле Instance.

Answer 3

Jus, чтобы проиллюстрировать немного, как это может повысить производительность и память, вы можете попробовать это

using System; 

namespace ConsoleApplication11 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      var str = EmptyArray<string>.Instance; 
      var intTest = EmptyArray<int>.Instance; 
      var intTest1 = EmptyArray<int>.Instance; 
      var str1 = EmptyArray<string>.Instance; 
      Console.WriteLine(str.GetType()); 
      Console.WriteLine(intTest.GetType()); 
      if (ReferenceEquals(str,str1)) 
      { 
       Console.WriteLine("References are equals"); 
      } 
      if (ReferenceEquals(intTest,intTest1))    
      { 
       Console.WriteLine("References are equals"); 
      } 

     } 
    } 

    public static class EmptyArray<T> 
    { 
     public static readonly T[] Instance; 

     static EmptyArray() 
     { 
      Instance = new T[0]; 
     } 
    } 
} 

вы можете увидеть, что никакое другое распределение не требуется даже для типа значения и при условии, что распределение и уничтожение объектов это время и потребляя память, вы можете улучшить свой код, делая это