Почему C # использует структуры вместо классов для внутренних KeyValuePairs

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

Если Dictionary должен поддерживать массив ссылок на объекты с ключом-стоимостью, стоимость того, чтобы его перечислитель возвращал ссылки на элементы в этом массиве, был бы немного меньше, чем стоимость того, чтобы вернуть экземпляр элементов из массива, структуры пары ценностей. Кроме того, когда словарь расширяется, стоимость копирования ссылок на объекты с ключом будет немного меньше стоимости копирования структур пары "ключ-значение". Однако общая стоимость добавления предметов в словарь будет увеличена, так же как и стоимость извлечения значений (в отличие от пар ключ-значение). Для большинства распространенных случаев использования словаря использование объекта "ключ-значение-пара" окажется более дорогостоящим, чем использование структуры.

В дополнение к причинам, которые вы указали, еще одна важная причина, по которой вы можете использовать структуры, состоит в том, что две структуры с одинаковым значением считаются равными при использовании с методом Equals() если метод equals не переопределяется, поскольку они являются значениями типы, подобно двум переменным типа int будут равны, если они имеют одинаковое значение. Ссылаясь на документацию для KeyValuePair, вы можете видеть, что метод Equals наследуется от ValueType, который выполняет как таковой, когда сравниваются два значения. Это важно для пар ключ/значение из-за выполняемого ими задания, которое содержит значения с уникальными ключами в коллекции, а операции против этих пар используют метод Equals под капотом, когда вы проверяете, есть ли в нем ключ Коллекция.

Например, предположим, что у вас есть эта структура:

struct MyStruct
{
    public System.IO.Stream Value { get; set; }
}

Следующее выведет "True":

var input = System.IO.File.OpenRead(myPath);
var myFirstStruct = new MyStruct();
var mySecondStruct = new MyStruct();
myFirstStruct.Value = input;
mySecondStruct.Value = input;
System.Diagnostics.Debug.Print(myFirstStruct.Equals(mySecondStruct).ToString());

Но если у меня есть этот класс:

class MyClass
{
    public System.IO.Stream Value { get; set; }
}

Затем выводится "False":

var input = System.IO.File.OpenRead(myPath);
var myFirstClass = new MyClass();
var mySecondClass = new MyClass();
myFirstClass.Value = input;
mySecondClass.Value = input;
System.Diagnostics.Debug.Print(myFirstClass.Equals(mySecondClass).ToString());

Увидеть разницу? Во втором примере два экземпляра не равны, поскольку классы являются ссылочными типами, а не типами значений.

Классы являются ссылочными типами. Структуры - это типы значений. Делает смысл семантически (и, возможно, логически), что значение в KeyValuePair будет доступно как тип значения.