Почему векторный массив удвоен?

Результаты профиля Greg являются большими для точного сценария, который он покрыл, но интересно, относительные затраты на различные методы изменяются существенно при считании многих различных факторов включая количество типов сравненными, и частотность и любые шаблоны в базовых данных.

простой ответ - то, что никто не может сказать Вам, чем различие в производительности будет в Вашем определенном сценарии, необходимо будет измерить уровень по-разному сами в собственной системе для получения точного ответа.

, Если/Еще цепочка является эффективным подходом для небольшого количества сравнений типов, или если можно надежно предсказать, который немного типов собираются составить большинство из тех, что Вы видите. Потенциальная проблема с подходом состоит в том, что как количество увеличений типов, количество сравнений, которые должны быть выполнены увеличения также.

, если я выполняю следующее:

int value = 25124;
if(value == 0) ...
else if (value == 1) ...
else if (value == 2) ...
...
else if (value == 25124) ... 

каждый из предыдущих, если условия должны быть оценены перед корректным блоком, вводится. С другой стороны

switch(value) {
 case 0:...break;
 case 1:...break;
 case 2:...break;
 ...
 case 25124:...break;
}

выполнит один простой переход к корректному биту кода.

то, Где это становится более сложным в Вашем примере, - то, что Ваш другой метод использует переключатель на строках, а не целых числах, который становится немного более сложным. На низком уровне строки не могут быть включены таким же образом, что целочисленные значения могут так компилятор C# делать некоторое волшебство сделать эту работу для Вас.

, Если оператор переключения является "достаточно небольшим" (то, где компилятор делает то, что это думает, является лучшим автоматически), включение строк генерирует код, который совпадает с если/еще цепочка.

switch(someString) {
    case "Foo": DoFoo(); break;
    case "Bar": DoBar(); break;
    default: DoOther; break;
}

совпадает с:

if(someString == "Foo") {
    DoFoo();
} else if(someString == "Bar") {
    DoBar();
} else {
    DoOther();
}

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

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

А, статическое поле определяется в "скрытом" месте, которое связано с классом, содержащим оператор переключения типа Dictionary<string, int>, и дано скорректированное имя

//Make sure the dictionary is loaded
if(theDictionary == null) { 
    //This is simplified for clarity, the actual implementation is more complex 
    // in order to ensure thread safety
    theDictionary = new Dictionary<string,int>();
    theDictionary["Foo"] = 0;
    theDictionary["Bar"] = 1;
}

int switchIndex;
if(theDictionary.TryGetValue(someString, out switchIndex)) {
    switch(switchIndex) {
    case 0: DoFoo(); break;
    case 1: DoBar(); break;
    }
} else {
    DoOther();
}

В некоторых быстрых тестах, которые я просто запустил, Если/Еще метод о 3x с такой скоростью, как переключатель для 3 различных типов (где типы случайным образом распределяются). В 25 типах переключатель быстрее маленьким полем (16%) в 50 типах, которые переключатель более двух раз как быстро.

, Если бы Вы собираетесь быть включением большого количества типов, я предложил бы 3-й метод:

private delegate void NodeHandler(ChildNode node);

static Dictionary<RuntimeTypeHandle, NodeHandler> TypeHandleSwitcher = CreateSwitcher();

private static Dictionary<RuntimeTypeHandle, NodeHandler> CreateSwitcher()
{
    var ret = new Dictionary<RuntimeTypeHandle, NodeHandler>();

    ret[typeof(Bob).TypeHandle] = HandleBob;
    ret[typeof(Jill).TypeHandle] = HandleJill;
    ret[typeof(Marko).TypeHandle] = HandleMarko;

    return ret;
}

void HandleChildNode(ChildNode node)
{
    NodeHandler handler;
    if (TaskHandleSwitcher.TryGetValue(Type.GetRuntimeType(node), out handler))
    {
        handler(node);
    }
    else
    {
        //Unexpected type...
    }
}

Это подобно тому, что предложенный Ted Elliot, но использование типа выполнения обрабатывает вместо полных текстовых объектов, избегает издержек загрузки текстового объекта посредством отражения.

Вот некоторые быстрые синхронизации на моей машине:

Testing 3 iterations with 5,000,000 data elements (mode=Random) and 5 types
Method                Time    % of optimal
If/Else               179.67  100.00
TypeHandleDictionary  321.33  178.85
TypeDictionary        377.67  210.20
Switch                492.67  274.21

Testing 3 iterations with 5,000,000 data elements (mode=Random) and 10 types
Method                Time    % of optimal
If/Else               271.33  100.00
TypeHandleDictionary  312.00  114.99
TypeDictionary        374.33  137.96
Switch                490.33  180.71

Testing 3 iterations with 5,000,000 data elements (mode=Random) and 15 types
Method                Time    % of optimal
TypeHandleDictionary  312.00  100.00
If/Else               369.00  118.27
TypeDictionary        371.67  119.12
Switch                491.67  157.59

Testing 3 iterations with 5,000,000 data elements (mode=Random) and 20 types
Method                Time    % of optimal
TypeHandleDictionary  335.33  100.00
TypeDictionary        373.00  111.23
If/Else               462.67  137.97
Switch                490.33  146.22

Testing 3 iterations with 5,000,000 data elements (mode=Random) and 25 types
Method                Time    % of optimal
TypeHandleDictionary  319.33  100.00
TypeDictionary        371.00  116.18
Switch                483.00  151.25
If/Else               562.00  175.99

Testing 3 iterations with 5,000,000 data elements (mode=Random) and 50 types
Method                Time      % of optimal
TypeHandleDictionary  319.67    100.00
TypeDictionary        376.67    117.83
Switch                453.33    141.81
If/Else               1,032.67  323.04

На моей машине, по крайней мере, подход словаря дескриптора типа бьет всех другие для чего-либо более чем 15 различных типов, когда распределение типов, используемых в качестве входа к методу, случайно.

, Если, с другой стороны, вход составлен полностью типа, который проверяется сначала в, если/еще цепочка, что метод очень быстрее:

Testing 3 iterations with 5,000,000 data elements (mode=UniformFirst) and 50 types
Method                Time    % of optimal
If/Else               39.00   100.00
TypeHandleDictionary  317.33  813.68
TypeDictionary        396.00  1,015.38
Switch                403.00  1,033.33

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

Testing 3 iterations with 5,000,000 data elements (mode=UniformLast) and 50 types
Method                Time      % of optimal
TypeHandleDictionary  317.67    100.00
Switch                354.33    111.54
TypeDictionary        377.67    118.89
If/Else               1,907.67  600.52

, Если можно сделать некоторые предположения о входе, Вы могли бы получить лучшую производительность от гибридного подхода, где Вы выполняете, если/еще проверки на несколько типов, которые наиболее распространены, и затем отступают к управляемому словарем подходу, если те перестали работать.