Чому в C # вказується тип рядка, який поводиться як тип значення?

Рядок - це тип посилання, хоча він має більшість характеристик типу значень, таких як незмінність і перевантаження == для порівняння тексту, а не переконання, що вони посилаються на один і той же об'єкт.

Чому тоді рядок не є лише типом значення?

Рядки не є типовими значеннями, оскільки вони можуть бути величезними, і їх потрібно зберігати у купі. Типи значень (у всіх реалізаціях CLR досі) зберігаються у стеці. Виділення рядків у стеку може порушити всілякі речі: стек становить лише 1 Мб для 32-бітових і 4 Мб для 64-бітових, вам потрібно буде встановити в поле кожну рядок, понесла покарання за копію, ви не змогли інтернувати рядки та використання пам'яті. повітряна куля тощо.

(Редагувати. Додано роз'яснення про те, що сховище значень типу є деталізацією реалізації, що призводить до такої ситуації, коли у нас є тип із значеннями сематики, що не успадковується від System.ValueType. Дякую Бен.)

Це не тип значення, оскільки продуктивність (простір та час!) Була б жахливою, якби це тип значення, і його значення доводилося копіювати кожного разу, коли воно передавались та поверталися з методів тощо.

Він має ціннісну семантику, щоб підтримувати здоровий світ. Ви можете собі уявити, як важко було б кодувати, якби

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

налаштований bбути false? Уявіть, як складно буде кодування майже будь-якої програми.

Відмінність типів відліку та типів значень в основному є компромісом продуктивності мови. Довідкові типи мають певні накладні витрати на будівництво та знищення та вивезення сміття, оскільки вони створюються на купі. Типи значень, з іншого боку, мають накладні витрати на виклики методів (якщо розмір даних більший за покажчик), оскільки весь об'єкт скопійований, а не лише вказівник. Оскільки рядки можуть бути (і зазвичай є) набагато більшими за розмір вказівника, вони розроблені як еталонні типи. Крім того, як Серві вказував, розмір типу значення повинен бути відомий під час компіляції, що не завжди стосується рядків.

Питання про незмінність - окреме питання. Як типи посилань, так і типи значень можуть бути або змінними, або незмінними. Типи значень, як правило, незмінні, оскільки семантика типів змінних значень може бути заплутаною.

Довідкові типи, як правило, змінюються, але можуть бути розроблені як незмінні, якщо це має сенс. Рядки визначаються як незмінні, оскільки це робить можливими певні оптимізації. Наприклад, якщо один і той же рядковий літерал трапляється кілька разів в одній програмі (що досить часто), компілятор може повторно використовувати той самий об'єкт.

Так чому "==" перевантажений для порівняння рядків за текстом? Тому що це найкорисніша семантика. Якщо два рядки однакові за текстом, вони можуть бути або не бути однаковими посиланнями на об'єкт через оптимізацію. Тому порівнювати посилання досить марно, тоді як порівнювати текст - це майже завжди те, що ви хочете.

Якщо говорити загальніше, Strings має те, що називається семантикою значення . Це більш загальне поняття, ніж типи значень, що є специфікою C # для реалізації. Типи значень мають значення семантики значень, але типи посилань також можуть мати значення семантики. Коли тип має семантику значень, ви не можете реально визначити, чи є базовою реалізацією тип опорного типу або тип значення, тому ви можете врахувати цю деталь реалізації.

Це пізня відповідь на старе запитання, але у всіх інших відповідях відсутня суть, а саме те, що .NET не мав загальної інформації до .NET 2.0 у 2005 році.

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

Збереження типу значення в колекції, що не є загальним, потребує спеціального перетворення у тип, objectякий називається бокс. Коли CLR вказує тип значення, він загортає значення всередині a System.Objectі зберігає його в керованій купі.

Читання значення з колекції вимагає зворотної операції, яку називають розпакуванням.

І бокс, і розгортання мають незначну вартість: бокс вимагає додаткового розподілу, для розпакування необхідна перевірка типу.

Деякі відповіді неправильно стверджують, що stringніколи не могли бути реалізовані як тип значення, оскільки його розмір є змінним. Насправді легко реалізувати рядок як структуру даних фіксованої довжини за допомогою стратегії оптимізації малих рядків: рядки зберігатимуться в пам'яті безпосередньо як послідовність символів Unicode, за винятком великих рядків, які зберігатимуться як вказівник на зовнішній буфер. Обидва зображення можуть бути розроблені так, щоб вони мали однакову фіксовану довжину, тобто розмір вказівника.

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

Не тільки рядки є незмінними еталонними типами. Делегати з кількома ролями теж. Ось чому це безпечно писати

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

Я вважаю, що рядки незмінні, оскільки це найбезпечніший метод роботи з ними та розподілення пам'яті. Чому вони не є типовими значеннями? Попередні автори мають рацію щодо розміру стека і т. Д. Я також додам, що створення рядків типу посилань дозволяє заощадити на розмірі збірки, коли ви використовуєте ту саму постійну рядок у програмі. Якщо ви визначаєте

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

Цілком ймовірно, що обидва екземпляри константи "мій рядок" будуть виділені у вашому складі лише один раз.

Якщо ви хочете керувати рядками типу звичайного довідкового типу, покладіть рядок всередину нового StringBuilder (string s). Або використовувати MemoryStreams.

Якщо ви маєте створити бібліотеку, де ви очікуєте, що у ваших функціях буде передано величезний рядок, або визначте параметр як StringBuilder або як Stream.

Також реалізуються способи рядків (різні для кожної платформи) і коли ви почнете їх зшивати. Як і використання StringBuilder. Він виділяє буфер для копіювання, як тільки ви досягнете мети, він виділяє ще більше пам’яті для вас, сподіваючись, що якщо ви зробите велику конкатенацію, ефективність не буде перешкоджати.

Може, Джон Скіт може допомогти тут?

В основному це питання ефективності.

Якщо рядки поводяться як тип значення LIKE, це допомагає при написанні коду, але, якщо це буде значення типу BE, це призвело б до величезного успіху в продуктивності.

Щоб поглибити погляд, погляньте на приємну статтю про рядки в .net-рамках.

Дуже простими словами будь-яке значення, яке має певний розмір, може трактуватися як тип значення.

Як ви можете сказати string, що це еталонний тип? Я не впевнений, що має значення, як це реалізується. Рядки в C # незмінні саме тому, що вам не доведеться турбуватися з цього приводу.

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

Струни незмінні з дуже вагомих причин, це не має нічого спільного з тим, що він є еталонним типом, але має багато спільного з управлінням пам'яттю. Просто ефективніше створити новий об’єкт при зміні розміру рядка, ніж для переміщення речей на керованій купі. Я думаю, ви поєднуєте цінні / референтні типи та незмінні поняття об'єктів.

Щодо "==": Як ви сказали, "==" - це перевантаження оператора, і знову це було реалізовано з дуже вагомої причини, щоб зробити рамку більш корисною при роботі з рядками.

Це не так просто, як рядки складаються з масивів символів. Я дивлюся на рядки як масиви символів []. Тому вони знаходяться в купі, оскільки місце розташування опорної пам'яті зберігається в стеці і вказує на початок розташування пам'яті масиву в купі. Розмір рядка не відомий до його виділення ... ідеально підходить для купи.

Ось чому рядок дійсно незмінний, оскільки коли ви змінюєте його, навіть якщо він однакового розміру, компілятор цього не знає і повинен виділяти новий масив та призначати символи позиціям масиву. Це має сенс, якщо ви думаєте про струни як про спосіб, який мови захищає вас від необхідності виділяти пам'ять під час руху (читайте програму C як програмування)

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

Примітивні типи з плаваючою комою обробляються ФПУ, що має 80 біт.

Це все було вирішено задовго до того, як з'явилася мова OOP, щоб придушити визначення примітивного типу, і я припускаю, що тип значень - це термін, створений спеціально для мов OOP.