C # 'da, bir dizeyi başlatmak için string.Empty veya String.Empty veya “” kullanmalı mıyım?

C # 'da, bir dize değerini boş bir dize ile başlatmak istiyorum.

Bunu nasıl yapmalıyım? Doğru yol nedir ve neden?

string willi = string.Empty;

veya

string willi = String.Empty;

veya

string willi = "";

ya da ne?

Sizin ve ekibinizin en okunabilir bulduklarını kullanın.

Diğer yanıtlar, her kullandığınızda yeni bir dize oluşturulmasını önerdi "". Bu doğru değildir - dize stajı nedeniyle, montaj başına bir kez veya AppDomain başına bir kez (veya tüm süreç için muhtemelen bir kez - bu cephede emin değilim) oluşturulur. Bu fark önemsizdir - kitlesel, kitlesel olarak önemsizdir.

Ancak daha okunabilir bulduğunuz farklı bir konudur. Bu sübjektiftir ve kişiden kişiye değişecektir - bu yüzden ekibinizdeki çoğu insanın neye benzediğini bulmanızı ve tutarlılık için bununla gitmenizi öneririm. Şahsen ""okumayı daha kolay buluyorum .

Argüman ""ve " "birbirlerine kolayca karıştırılabilen olan beni gerçekten temizlenemez. Orantılı bir yazı tipi kullanmadığınız sürece (ve bunu yapan herhangi bir geliştiriciyle çalışmadıysanız ) farkı söylemek oldukça kolaydır.

Performans ve kod üretme açısından hiçbir fark yoktur. Performans testinde, biri diğerine göre daha hızlı olan ve sadece milisaniye kadar ileri geri gitti.

Sahne kodlarının arkasına baktığınızda, gerçekten de bir fark görmüyorsunuz. Tek fark IL, olduğu string.Emptyişlem kodu kullanmaya ldsfld ve ""kodunu kullanacak ldstr, fakat bunun tek nedeni olduğunu string.Emptystatik değildir ve her iki talimatlar aynı şeyi yaparlar. Üretilen montaja bakarsanız, tamamen aynıdır.

C # Kodu

private void Test1()
{
    string test1 = string.Empty;    
    string test11 = test1;
}

private void Test2()
{
    string test2 = "";    
    string test22 = test2;
}

IL Kodu

.method private hidebysig instance void 
          Test1() cil managed
{
  // Code size       10 (0xa)
  .maxstack  1
  .locals init ([0] string test1,
                [1] string test11)
  IL_0000:  nop
  IL_0001:  ldsfld     string [mscorlib]System.String::Empty
  IL_0006:  stloc.0
  IL_0007:  ldloc.0
  IL_0008:  stloc.1
  IL_0009:  ret
} // end of method Form1::Test1

.method private hidebysig instance void 
        Test2() cil managed
{
  // Code size       10 (0xa)
  .maxstack  1
  .locals init ([0] string test2,
                [1] string test22)
  IL_0000:  nop
  IL_0001:  ldstr      ""
  IL_0006:  stloc.0
  IL_0007:  ldloc.0
  IL_0008:  stloc.1
  IL_0009:  ret
} // end of method Form1::Test2

Montaj kodu

        string test1 = string.Empty;
0000003a  mov         eax,dword ptr ds:[022A102Ch] 
0000003f  mov         dword ptr [ebp-40h],eax 

        string test11 = test1;
00000042  mov         eax,dword ptr [ebp-40h] 
00000045  mov         dword ptr [ebp-44h],eax 

        string test2 = "";
0000003a  mov         eax,dword ptr ds:[022A202Ch] 
00000040  mov         dword ptr [ebp-40h],eax 

        string test22 = test2;
00000043  mov         eax,dword ptr [ebp-40h] 
00000046  mov         dword ptr [ebp-44h],eax 

En iyi kod hiç kod değildir :

Kodlamanın temel doğası, programcılar olarak görevimizin verdiğimiz her kararın bir değiş tokuş olduğunu tanımasıdır. […] Özlü bir şekilde başlayın. Test ederek gereken diğer boyutları artırın.

Sonuç olarak, daha az kod daha iyi koddur: veya seçeneğini tercih ""edin . Bu ikisi altı kat daha uzun ve ek bir faydası yok - aynı bilgileri ifade ettikleri için kesinlikle ek netlik yok.string.EmptyString.Empty

Bir fark, bir switch-casesözdizimi kullanırsanız , case string.Empty:sabit olmadığı için yazamazsınız . AlırsınCompilation error : A constant value is expected

Daha fazla bilgi için bu bağlantıya bakın: string-empty-versus-empty-quotes

Ben tercih ediyorum stringiçin String. seçerek string.Emptyüzerine ""birini seçerek ve bu kurallara uymanızı meselesidir. Kullanmanın avantajı, string.Emptyne demek istediğinizin çok açık olması ve yanlışlıkla "\x003"sizin gibi yazdırılamayan karakterlerin üzerine kopyalamamanızdır "".

Ben içeri girmeyecektim, ama burada yanlış bir bilgi olduğunu görüyorum.

Ben şahsen tercih ederim string.Empty. Bu kişisel bir tercihtir ve birlikte çalıştığım herhangi bir ekibin duruma göre eğilimi vardır.

Diğerlerinin de belirttiği gibi, string.Emptyve arasında hiçbir fark yoktur String.Empty.

Ayrıca, bu biraz bilinen bir gerçektir, "" kullanmak tamamen kabul edilebilir. Diğer ortamlarda her "" örneği bir nesne oluşturur. Ancak, .NET dizelerini stajyerler, böylece gelecekteki örnekler aynı değişmez dizeyi stajyer havuzundan çeker ve herhangi bir performans isabeti göz ardı edilebilir. Kaynak: Brad Abrams .

Daha karmaşık bir şey için iyi bir neden olmadığı sürece şahsen "" tercih ederim.

String.Emptyve string.Emptyeşdeğerdir. StringBCL sınıf adıdır; stringonun C # diğer adı (ya da eğer kısayol). İle aynı Int32ve int. Daha fazla örnek için dokümanlara bakın .

Söz ""konusu olduğunda, gerçekten emin değilim.

Şahsen ben her zaman kullanırım string.Empty.

Hemen hemen her geliştirici "" nin ne anlama geldiğini bilecek. Ben şahsen String.Empty ilk kez karşılaştı ve onlar gerçekten olmadığını anlamaya biraz zaman arama google geçirmek zorunda olan tam aynı şeyi.

Bu konu oldukça eski ve uzundur, bu yüzden bu davranış başka bir yerde bahsedildiyse özür dilerim. (Ve beni bunu kapsayan cevaba yönlendirin)

Kullanırsanız derleyicinin davranışında bir fark buldum string.EmptyÇift tırnak . String.Empty veya çift tırnak ile başlatılmış dize değişkenini kullanmazsanız, fark kendini gösterir.

string.EmptyDerleyici ile başlatma durumunda Derleyici Uyarısı

CS0219 - The variable 'x' is assigned but its value is never used

çift ​​tırnak ile başlatma durumunda beklenen mesajı alırken asla yayılmaz.

Bu davranış, bu bağlantıdaki Connect makalesinde açıklanmıştır: https://connect.microsoft.com/VisualStudio/feedback/details/799810/c-warning-cs0219-not-reported-when-assign-non-constant-value

Temel olarak, eğer doğru yaparsam, bir programcıya bir uyarı mesajı ile rahatsız etmeden hata ayıklama amacıyla bir işlevin dönüş değeri olan bir değişken ayarlamasına izin vermek isterler ve böylece uyarıyı yalnızca costant atamaları ve dizgisi durumunda sınırlarlar. Boş bir sabit değil, bir alandır.

Bu çok basit testi bir konsol uygulamasında aşağıdaki yöntemi kullanarak gerçekleştirdim:

private static void CompareStringConstants()
{
    string str1 = "";
    string str2 = string.Empty;
    string str3 = String.Empty;
    Console.WriteLine(object.ReferenceEquals(str1, str2)); //prints True
    Console.WriteLine(object.ReferenceEquals(str2, str3)); //prints True
}

Bu açık bir şekilde, yani her üç değişkenin düşündürmektedir str1, str2ve str3farklı bir sözdizimi kullanılarak başlatıldı da bellekte nesne (sıfır uzunluk) aynı dizeye işaret ediyor. Bu testi .NET 4.5 konsol uygulamasında gerçekleştirdim. Yani dahili olarak hiçbir farkları yoktur ve hepsi bir programcı olarak kullanmak istediğinizi kolaylaştırır. Dize sınıfının bu davranışı, .NET'te dize interning olarak bilinir . Eric Lippert'in bu konsepti anlatan çok güzel bir blogu var .

Yukarıdakilerden herhangi biri.

Ahlaksız çok, çok daha iyi şeyler vardır. Renk kabuğunun bir ağaca en uygun olduğu gibi, sanırım dulcet yosununun tonları ile belirsiz kahverengi.

Ne olduğunu ve yanlışlıkla içeriği kaldırmadıklarını, ancak öncelikle uluslararasılaştırma için emin olmak için diğer nedenlerin yanı sıra, String.Empty tercih ederim. Tırnak içinde bir dize görürseniz, o zaman her zaman bu yeni kod olup olmadığını merak etmeliyim ve bir dize tabloya konmalıdır. Bu nedenle, kod her değiştiğinde / incelendiğinde "tırnak içinde bir şey" aramanız gerekir ve evet, boş dizeleri filtreleyebilirsiniz, ancak insanlara, yerelleştirilmeyeceğini bilmediğiniz sürece hiçbir zaman tırnak işaretleri koymanın iyi bir uygulama olduğunu söylüyorum .

Hiç kimse VisualStudio Dize'de renk kodundan farklı olarak dize olduğundan bahsetmedi. Okunabilirlik için önemlidir. Ayrıca, küçük harf genellikle vars ve type için kullanılır, büyük bir anlaşma değil, String.Empty bir sabittir ve bir var veya type değildir.

string eşanlamlı System.Stringtipiyle , özdeştir.

Değerler de aynıdır: string.Empty == String.Empty == ""

Ben karakter sabit "" kod kullanmaz, daha doğrusu string.Emptyveya String.Empty- programcı ne anlama geldiğini görmek daha kolay.

Arasında stringve küçük harfleri daha Stringçok seviyorum stringçünkü eskiden Delphi ile uzun yıllar çalışıyordum ve Delphi stili küçük harfstring .

Patronun ben olsaydım, sen yazıyordun string.Empty

Ben iyilik ediyorum string.Emptyüzerinde String.Emptysize a içerecek şekilde gerek kalmadan kullanabilirsiniz, çünküusing System; Dosyanda.

Toplama gelince ""üzerine string.Empty, kişisel tercihi ve ekibi tarafından karar verilmelidir.

Fark etmiyorum. Sonuncusu yine de yazmanın en hızlısıdır :)

Önemli değil - tamamen aynı şey. Ancak, asıl önemli olan tutarlı gerektiğidir

ps Ben her zaman "doğru olanı" bu tür mücadele.

Tamamen bir kod stili tercihi, .NET'in dizeleri nasıl işlediğini yap. Ancak, işte benim görüşlerim :)

Statik yöntemlere, özelliklere ve alanlara erişirken her zaman BCL Türü adlarını kullanırım: String.Emptyveya Int32.TryParse(...)veyaDouble.Epsilon

Her zaman yeni örnekleri bildirirken C # anahtar sözcüklerini kullanırım: int i = 0;veyastring foo = "bar";

Onları yeniden adlandırılmış sabitler olarak birleştirmek için kodu tarayabilmek gibi nadiren bildirilmemiş dize değişmezleri kullanın. Derleyici, sabitleri zaten değişmez değerlerle değiştirir, böylece bu, sihirli dizelerden / sayılardan kaçınmanın ve onlara bir adla biraz daha fazla anlam vermenin bir yoludur. Artı değerleri değiştirmek daha kolaydır.

Üçüncüyü kullanıyorum, ancak diğer ikisinden ilkinin daha az garip görünüyor. dize, Dize için bir takma addır, ancak bunları bir ödevde görmek kendini hissettirir.

İlk ikisinden biri benim için kabul edilebilir. Sonuncusundan kaçınırdım çünkü tırnaklar arasında boşluk bırakarak bir hatayı tanıtmak nispeten kolaydır. Bu özel hatanın gözlem yoluyla bulunması zor olacaktır. Yazım hatası olmadığı varsayıldığında, hepsi anlamsal olarak eşdeğerdir.

[DÜZENLE]

Ayrıca, her zaman ya stringda Stringtutarlılık için kullanmak isteyebilirsiniz , ama bu sadece benim.

Şahsen "" küçük sorunlara yol açan iki kez şahit oldum. Bir zamanlar, takım tabanlı programlamaya yeni başlayan bir genç geliştiricinin hatasıydı ve diğeri basit bir yazım hatasıydı, ancak gerçek string kullanıyor.

Evet, bu bir yargılama çağrısıdır, ancak bir dil size bir şeyler yapmanın birden fazla yolunu verdiğinde, en derleyici denetimine ve en güçlü derleme zamanı uygulamasına sahip olana doğru eğilme eğilimindeyim. Bu "" değil . Her şey belirli bir amacı ifade etmekle ilgilidir.

String.EMpty veya Strng.Empty yazarsanız, derleyici yanlış yaptığınızı bildirir. Hemen. Sadece derlenmeyecek. Bir geliştirici olarak , derleyicinin (veya başka bir geliştiricinin) herhangi bir şekilde yanlış yorumlayamayacağına ve yanlış yaptığınızda, bir hata oluşturamayacağınıza dair özel bir niyet belirtiyorsunuz.

"" Demek istediğinizde "" yazarsanız veya bunun tersini yaparsanız, derleyici bunu yapmasını söylediklerinizi mutlu bir şekilde yapar. Başka bir geliştirici sizin özel niyetinizi belirtebilir veya edemeyebilir. Hata oluşturuldu.

String'den çok önce.Empty, EMPTY_STRING sabitini tanımlayan standart bir kitaplık kullandığım bir şeydi. String.mpty öğesine izin verilmeyen durumlarda deyimleri hala bu sabiti kullanıyoruz.

Mümkün olan her durumda, derleyiciyi sizin için çalışmaya bırakın ve ne kadar küçük olursa olsun insan hatası olasılığını ortadan kaldırın. IMO, diğerlerinin belirttiği gibi "okunabilirliği" yıpratır.

Özgüllük ve derleme zorlaması. Akşam yemeği için ne var.

"" Kullanıyorum çünkü kodumda belirgin olarak sarı renkte olacak ... Nedense String.Empty tamamen Visual Studio Code temamda beyaz. Ve bunun benim için en önemli olduğuna inanıyorum.

Derleyici uzun vadede hepsini aynı yapmalıdır. Kodunuzun okunması kolay olacak bir standart seçin ve ona uyun.

Sadece bazı kodlara bakıyordum ve bu soru daha önce biraz zaman okuduğum aklıma girdi. Bu kesinlikle okunabilirlik meselesidir.

Aşağıdaki C # kodunu düşünün ...

(customer == null) ? "" : customer.Name

vs

(customer == null) ? string.empty : customer.Name

Şahsen ikincisini daha az belirsiz ve okunması daha kolay buluyorum.

Başkaları tarafından işaret edildiği gibi, gerçek farklılıklar göz ardı edilebilir.

Sanırım ikincisi "uygun" ama dürüst olmak gerekirse bunun önemli olacağını düşünmüyorum. Derleyici, bunlardan herhangi birini tam olarak aynı bayt koduna derleyecek kadar akıllı olmalıdır. Kendimi "" kullanıyorum.

Fark çok, çok az olsa da, fark hala var.

1) "", String.Empty oluşturmazken nesne oluşturur. Ancak bu nesneye bir kez oluşturulacak ve kodda başka bir "" varsa daha sonra string havuzundan referans alınacaktır.

2) Dize ve dize aynıdır, ancak nokta gösterimi operatörü değil, sınıfı ve büyük harfle başlayan sınıfı olması gerektiği için String.Empty (hem de String.Format, String.Copy vb.) Kullanmanızı öneririm. C # kodlama standartları.

Açık http://blogs.msdn.com/b/brada/archive/2003/04/22/49997.aspx :

David'in ifade ettiği gibi, arasında String.Emptyve ""oldukça küçük fark vardır, ancak bir fark vardır. ""aslında bir nesne oluşturur, muhtemelen dize stajyer havuzundan çekilecektir, ama yine de ... String.Emptyhiçbir nesne oluşturmazken ... bu yüzden sonuçta gerçekten bellek verimliliğinde arıyorsanız, öneririm String.Empty. Ancak, fark o kadar ... Eğer kodunda görebilirsiniz asla sever olacak TRIVAL olduğu akılda tutmalı
için Farklı System.String.Emptyveya string.Emptyveya String.Empty;-) ... benim bakım seviyesi düşük

Boş dize, tıpkı herkesin aramak için kullandığı bir ad gibi boş bir küme gibidir "". Ayrıca resmi dillerde, sıfır uzunlukta bir alfabeden oluşturulan dizelere boş dize denir. Hem kümenin hem de dizenin bunun için özel bir sembolü vardır. Boş dize: ε ve boş küme: ∅. Bu sıfır uzunluklu dize hakkında konuşmak istiyorsanız, boş dize olarak adlandırılırsınız, böylece herkes ne demek istediğinizi tam olarak bilir. Şimdi boş dize olarak adlandırmanız durumunda neden string.Emptykodda kullanılmıyorsa, niyetin açık olduğunu gösterir. Dezavantajı, sabit olmadığı ve bu nedenle niteliklerde olduğu gibi her yerde mevcut olmamasıdır. (Bazı teknik nedenlerden dolayı sabit değildir, referans kaynağına bakın.)

Daha ""kısa olduğu ve String.Emptyvar olmayan bir sorunu çözdüğü için tercih ederim .