C # 'da, String neden bir değer türü gibi davranan bir başvuru türüdür?

Bir String, aynı nesneye başvurduklarından emin olmak yerine, metni karşılaştırmak için değişmez olma ve == aşırı yüklenme gibi bir değer türünün özelliklerinin çoğuna sahip olmasına rağmen bir referans türüdür.

Neden string sadece bir değer türü değil?

Dizeler, büyük olabileceğinden ve yığın üzerinde depolanması gerektiğinden değer türleri değildir. Değer türleri (henüz CLR'nin tüm uygulamalarında) yığın üzerinde depolanır. Yığın ayırma dizeleri her türlü şeyi kıracaktır: yığın 32 bit için sadece 1 MB ve 64 bit için 4 MB, her dizeyi kutlamanız, bir kopya cezası vermeniz, sabit dizeler ve bellek kullanımı yapmamanız gerekir balon, vs ...

(Düzenleme: Değer türü depolamanın, bir uygulama ayrıntısı olmasıyla ilgili açıklama eklendi; bu, System.ValueType öğesinden devralmayan değer sinemasına sahip bir türümüzün olduğu bu duruma yol açar.

Bu bir değer türü değildir, çünkü değer (alan ve zaman!), Bir değer türü olsaydı ve yöntemlere her aktarıldığında ve yöntemlerden döndürüldüğünde değerinin kopyalanması gerektiğinde korkunç olurdu.

Dünyayı aklı başında tutmak için değer semantiğine sahiptir. Kodlamanın ne kadar zor olacağını hayal edebiliyor musunuz?

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

set bolmak false? Herhangi bir uygulama hakkında kodlamanın ne kadar zor olacağını düşünün.

Referans türleri ve değer türleri arasındaki ayrım, temel olarak dilin tasarımında bir performans dengesidir. Referans türlerinin, yığın üzerinde oluşturuldukları için inşaat ve imha ve çöp toplama üzerinde bazı ek yükleri vardır. Öte yandan değer türleri, yöntem çağrılarında (veri boyutu bir işaretçiden büyükse) ek yüke sahiptir, çünkü tüm nesne yalnızca bir işaretçi yerine kopyalanır. Dizeler bir işaretçinin boyutundan çok daha büyük (ve tipik olarak) olduğundan, başvuru türleri olarak tasarlanmıştır. Ayrıca, Servy'nin işaret ettiği gibi, bir değer türünün boyutu derleme zamanında bilinmelidir, bu da dizeler için her zaman geçerli değildir.

Değişebilirlik sorunu ayrı bir konudur. Hem referans tipleri hem de değer tipleri değişebilir ya da değişmez olabilir. Değişken değer türleri için semantikler kafa karıştırıcı olabileceğinden değer türleri tipik olarak değişmezdir.

Referans tipleri genellikle değişkendir, ancak mantıklıysa değişmez olarak tasarlanabilir. Dizeler değişmez olarak tanımlanır, çünkü belirli optimizasyonları mümkün kılar. Örneğin, aynı dize değişmez değeri aynı programda (bu oldukça yaygın olan) birden çok kez oluşursa, derleyici aynı nesneyi yeniden kullanabilir.

Öyleyse neden dizeleri metne göre karşılaştırmak için "==" aşırı yüklenmiş? Çünkü en kullanışlı anlambilimdir. İki dize metne eşitse, optimizasyonlar nedeniyle aynı nesne başvurusu olabilir veya olmayabilir. Bu yüzden referansları karşılaştırmak oldukça işe yaramazken, metni karşılaştırmak neredeyse her zaman istediğiniz şeydir.

Daha genel olarak konuşmak gerekirse, Dizeler değer semantiği olarak adlandırılır . Bu, C #'a özgü bir uygulama ayrıntısı olan değer türlerinden daha genel bir kavramdır. Değer türlerinde değer semantiği vardır, ancak başvuru türlerinde değer semantiği de olabilir. Bir tür değer semantiğine sahip olduğunda, temeldeki uygulamanın bir referans türü mü yoksa değer türü mü olduğunu gerçekten anlayamazsınız, bu nedenle bir uygulama ayrıntısını düşünebilirsiniz.

Bu eski bir soruya geç bir cevaptır, ancak diğer tüm cevaplar noktayı kaçırmaktadır, yani 2005'te .NET 2.0'a kadar .NET'in jenerikleri yoktu.

StringÇünkü yerine bir değer türünde bir referans türüdür Microsoft bu dizeleri olmayan jenerik koleksiyonlarında en verimli şekilde saklanabilir sağlamak için daha büyük önem taşımaktadır oldu gibi System.Collections.ArrayList.

Bir değer türünü genel olmayan bir koleksiyonda depolamak object, boks adı verilen türe özel bir dönüşüm gerektirir . CLR bir değer türünü işaretlediğinde, a içindeki değeri sarar System.Objectve yönetilen yığında saklar.

Koleksiyondaki değerin okunması, kutudan çıkarma adı verilen ters işlem gerektirir.

Hem boks hem de boksun ihmal edilemez maliyeti vardır: boks ek bir tahsis gerektirir, kutudan çıkarma tip kontrolü gerektirir.

Bazı cevaplar string, boyutu değişken olduğu için hiçbir zaman değer türü olarak uygulanamayacağını yanlış iddia ediyor . Aslında bir Küçük Dize Optimizasyonu stratejisi kullanarak dizeyi sabit uzunluklu bir veri yapısı olarak uygulamak kolaydır: dizeler, harici bir arabelleğe işaretçi olarak depolanacak büyük dizeler dışında doğrudan Unicode karakter dizisi olarak depolanır. Her iki gösterim de aynı sabit uzunluğa, yani bir işaretçinin boyutuna sahip olacak şekilde tasarlanabilir.

Eğer jenerikler ilk günden itibaren mevcut olsaydı, değer tipi olarak dizgiye sahip olmak sanırım daha basit anlambilim, daha iyi bellek kullanımı ve daha iyi önbellek konumuyla daha iyi bir çözüm olurdu. Bir List<string>içeren sadece küçük şeritler bellek tek bir bitişik blok olabilirdi.

Sadece dizgiler değişmez referans tipleridir. Çoklu oyuncu delegeleri de. Bu yüzden yazmak güvenlidir

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

Bu dizeleri değişmez olduğunu düşünüyorum çünkü bu onlarla çalışmak ve bellek ayırmak için en güvenli yöntemdir. Neden Değer türleri değil? Önceki yazarlar yığın boyutu vb. Hakkında haklıyım. Ayrıca, dizelerde bir başvuru türünün, programda aynı sabit dizeyi kullandığınızda montaj boyutundan tasarruf etmesini sağladığını da ekleyeceğim. Eğer tanımlarsan

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

Şansınız, "dizem" sabitinin her iki örneğinin de derlemenize yalnızca bir kez tahsis edilmesidir.

Dizeleri normal referans türü gibi yönetmek istiyorsanız, dizeyi yeni bir StringBuilder (dize s) içine yerleştirin. Veya MemoryStreams kullanın.

İşlevlerinizde büyük bir dizenin geçmesini beklediğiniz bir kütüphane oluşturacaksanız, bir parametreyi StringBuilder veya Stream olarak tanımlayın.

Ayrıca, dizelerin uygulanma şekli (her platform için farklıdır) ve bunları birleştirmeye başladığınızda. A kullanmak gibi StringBuilder. Kopyalamanız için bir arabellek ayırır, sonuna ulaştığınızda, büyük bir birleştirme performansının engellenmemesi umuduyla sizin için daha da fazla bellek ayırır.

Belki Jon Skeet buraya yardım edebilir mi?

Esas olarak bir performans sorunudur.

Dizelerin LIKE değer türüne sahip olması, kod yazarken yardımcı olur, ancak bir değer türünün BE olması, büyük bir performans isabeti yaratacaktır.

Derinlemesine bir görünüm için, .net çerçevesindeki dizelerle ilgili güzel bir makaleye göz atın .

Çok basit bir deyişle, belirli bir boyuta sahip herhangi bir değer, bir değer türü olarak ele alınabilir.

stringBir referans türü olduğunu nasıl anlarsınız ? Nasıl uygulandığından emin değilim. C # dizeleri tam olarak değişmez, böylece bu sorun hakkında endişelenmenize gerek yok.

Aslında dizelerin değer türlerine çok az benzerlikleri vardır. Yeni başlayanlar için, tüm değer türleri değiştirilemez, bir Int32'nin değerini istediğiniz gibi değiştirebilirsiniz ve yine de yığın üzerinde aynı adres olacaktır.

Dizeler çok iyi bir nedenden dolayı değişmez, referans türü olmasıyla hiçbir ilgisi yoktur, ancak bellek yönetimi ile ilgisi vardır. Dize boyutu değiştiğinde, yönetilen öbek üzerinde bir şeyleri kaydırmak yerine yeni bir nesne oluşturmak daha etkilidir. Bence değer / referans türlerini ve değişmez nesne kavramlarını karıştırıyorsunuz.

"==": Dediğiniz gibi "==" bir operatör aşırı yüküdür ve yine dizelerle çalışırken çerçeveyi daha kullanışlı hale getirmek için çok iyi bir nedenden dolayı uygulanmıştır.

Dizeler karakter dizilerinden oluştuğu kadar basit değildir. Dizelere karakter dizileri olarak bakıyorum []. Bu nedenle, yığın bellekte olduğundan, yığın bellekte saklanır ve dizinin yığın üzerindeki bellek konumunun başlangıcına işaret eder. Dize boyutu ayrılmadan önce bilinmemektedir ... yığın için mükemmeldir.

Bu nedenle bir dize gerçekten değişmezdir, çünkü aynı boyutta olsa bile değiştirdiğinizde derleyici bunu bilmez ve yeni bir dizi tahsis etmeli ve dizideki konumlara karakterler atamalıdır. Dizeleri, dillerin sizi anında bellek ayırmaktan koruyacak bir yol olarak düşünmeniz mantıklıdır (C gibi programlama okuyun)

Bir başka gizemli aşağı oy alma riski altında ... birçoğunun değer türlerine ve ilkel türlere göre yığın ve hafızadan bahsetmesi, mikroişlemcideki bir sicile uymaları gerektiğidir. Bir kaydın sahip olduğundan daha fazla bit alırsa yığına / yerden bir şey itemez veya patlatamazsınız ... talimatlar örneğin "pop eax" - çünkü eax 32 bit sistemde 32 bit genişliğindedir.

Kayan noktalı ilkel tipler 80 bit genişlikteki FPU tarafından ele alınır.

Tüm bunlara, ilkel tür tanımını gizlemek için bir OOP dili gelmeden çok önce karar verildi ve değer türünün özellikle OOP dilleri için yaratılmış bir terim olduğunu varsayıyorum.