В C # почему String является ссылочным типом, который ведет себя как тип значения?

https://stackoverflow.com/questions/636932

10-07-2019
|

Вопрос

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

Почему тогда строка не просто тип значения?

Решение

Строки не являются типами значений, поскольку они могут быть огромными и должны храниться в куче. Типы значений (во всех реализациях CLR на данный момент) хранятся в стеке. Строки, выделяющие стек, могут сломать все виды вещей: размер стека составляет всего 1 МБ для 32-разрядных и 4 МБ для 64-разрядных, вам нужно будет упаковать каждую строку, что приведет к штрафу за копирование, невозможность интернировать строки и использование памяти будет шар, и т.д ...

(Изменить: добавлено пояснение о том, что хранилище типов значений является деталью реализации, что приводит к такой ситуации, когда у нас есть тип с семантикой значений, не наследуемый от System.ValueType. Спасибо, Бен.)

Другие советы

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

У него есть ценностная семантика, чтобы держать мир в здравом уме. Можете ли вы представить, насколько сложно было бы написать код, если

string s = "hello";
string t = "hello";
bool b = (s == t);

установить b на false? Представьте себе, насколько сложным будет кодирование практически любого приложения.

Различие между ссылочными типами и типами значений в основном является компромиссом производительности при разработке языка. У ссылочных типов есть некоторые накладные расходы на создание, уничтожение и сборку мусора, поскольку они создаются в куче. С другой стороны, типы значений накладываются на вызовы методов (если размер данных больше, чем указатель), потому что весь объект копируется, а не только указатель. Поскольку строки могут быть (и обычно имеют размер) намного больше, чем размер указателя, они разработаны как ссылочные типы. Кроме того, как указал Servy, размер типа значения должен быть известен во время компиляции, что не всегда имеет место для строк.

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

Типы ссылок, как правило, являются изменяемыми, но могут быть разработаны как неизменяемые, если это имеет смысл. Строки определены как неизменяемые, потому что это делает возможной определенную оптимизацию. Например, если один и тот же строковый литерал встречается несколько раз в одной и той же программе (что довольно часто встречается), компилятор может повторно использовать один и тот же объект.

Так почему же " == " перегружен для сравнения строк по тексту? Потому что это самая полезная семантика. Если две строки равны по тексту, они могут или не могут быть одной и той же ссылкой на объект из-за оптимизации. Поэтому сравнение ссылок довольно бесполезно, тогда как сравнение текста почти всегда то, что вы хотите.

Говоря более широко, Strings имеет то, что называется семантикой значения . Это более общая концепция, чем типы значений, что является специфической реализацией C #. Типы значений имеют семантику значений, но ссылочные типы также могут иметь семантику значений. Когда у типа есть семантика значения, вы не можете точно сказать, является ли базовая реализация ссылочным типом или типом значения, поэтому вы можете считать это реализацией.

Это поздний ответ на старый вопрос, но во всех остальных ответах не хватает смысла, заключающегося в том, что в .NET не было дженериков до .NET 2.0 в 2005 году.

String является ссылочным типом, а не типом значения, потому что для Microsoft было крайне важно обеспечить, чтобы строки могли наиболее эффективно храниться в неуниверсальных коллекциях , таких как System.Collection.ArrayList.

Хранение типа значения в неуниверсальной коллекции требует специального преобразования в тип object, который называется боксом. Когда CLR упаковывает тип значения, он помещает значение в System.Object и сохраняет его в управляемой куче.

Чтение значения из коллекции требует обратной операции, которая называется распаковкой.

Бокс и распаковка имеют немаловажную стоимость: для бокса требуется дополнительное распределение, для распаковки требуется проверка типа.

В некоторых ответах неправильно утверждается, что string никогда нельзя было бы реализовать как тип значения, поскольку его размер является переменным. На самом деле, легко реализовать строку как структуру данных фиксированной длины, используя стратегию оптимизации небольших строк: строки будут храниться в памяти непосредственно как последовательность символов Юникода, за исключением больших строк, которые будут храниться в виде указателя на внешний буфер. Оба представления могут иметь одинаковую фиксированную длину, то есть размер указателя.

Если бы дженерики существовали с первого дня, я думаю, что иметь строку в качестве типа значения, возможно, было бы лучшим решением, с более простой семантикой, лучшим использованием памяти и лучшей локализацией кэша. List<string>, содержащий только небольшие строки, мог быть одним непрерывным блоком памяти.

Не только строки являются неизменяемыми ссылочными типами. Многоадресные делегаты тоже. Вот почему это безопасно писать

protected void OnMyEventHandler()
{
     delegate handler = this.MyEventHandler;
     if (null != handler)
     {
        handler(this, new EventArgs());
     }
}

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

string s1 = "my string";
//some code here
string s2 = "my string";

Скорее всего, оба экземпляра " моя строка " Константа будет выделена в вашей сборке только один раз.

Если вы хотите управлять строками, как обычным ссылочным типом, поместите строку в новый StringBuilder (string s). Или используйте MemoryStreams.

Если вы хотите создать библиотеку, в которой вы ожидаете, что в ваши функции будут переданы огромные строки, определите параметр как StringBuilder или как Stream.

Кроме того, как реализованы строки (разные для каждой платформы) и когда вы начинаете их соединять. Как и использование StringBuilder. Он выделяет буфер для вас, чтобы скопировать в него, как только вы достигнете конца, он выделит вам еще больше памяти, в надежде, что если вы сделаете большую конкатенацию, производительность не будет ограничена.

Может быть, Джон Скит может помочь здесь?

Это в основном проблема с производительностью.

Работа со строками. LIKE-тип значений помогает при написании кода, но наличие BE-типа приводит к значительному снижению производительности.

Подробно рассмотрите замечательную статью в строки в .net Framework.

Как вы можете определить, string это тип ссылки? Я не уверен, что это важно, как это реализовано. Строки в C # являются неизменяемыми, поэтому вам не нужно беспокоиться об этой проблеме.

На самом деле строки очень мало похожи на типы значений. Начнем с того, что не все типы значений являются неизменяемыми, вы можете изменить значение типа Int32 так, как вам будет угодно, и это будет тот же адрес в стеке.

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

Насколько " == " ;: Как вы сказали " == " это перегрузка оператора, и снова она была реализована по очень веской причине, чтобы сделать среду более полезной при работе со строками.

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

Не так просто, как строки состоят из массивов символов. Я смотрю на строки как на символьные массивы []. Поэтому они находятся в куче, поскольку эталонная ячейка памяти хранится в стеке и указывает на начало ячейки памяти массива в куче. Размер строки неизвестен до ее выделения ... идеально подходит для кучи.

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

Риск получить еще одно загадочное отрицательное голосование ... тот факт, что многие упоминают стек и память относительно типов значений и примитивных типов, заключается в том, что они должны вписываться в регистр в микропроцессоре. Вы не можете вытолкнуть или вытолкнуть что-либо в / из стека, если для этого требуется больше битов, чем в регистре .... инструкции, например, & Quot; pop eax & Quot; - потому что в 32-битной системе eax имеет ширину 32 бита.

Примитивные типы с плавающей запятой обрабатываются FPU, ширина которого составляет 80 бит.

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

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow