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

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

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

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

(Редактировать: Добавлено пояснение о том, что хранилище типов значений является подробностью реализации, что приводит к такой ситуации, когда у нас есть тип со значением sematics, не наследуемый от 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.Collections.ArrayList .

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

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

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

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

Если бы дженерики существовали с первого дня, я думаю, что иметь строку в качестве типа значения было бы лучшим решением, с более простой семантикой, лучшим использованием памяти и лучшей локализацией кэша. A , 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-тип значения помогает при написании кода, но наличие БИ-типа значения может привести к значительному снижению производительности.

Для более детального изучения взгляните на хорошую статью о строках в .net framework.

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

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

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

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

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

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

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

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

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

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