W C# powinienem użyć string.Pusty lub ciąg znaków.Empty lub "" aby zaintiializowaä ‡ ciÄ ... g?

Naprawdę nie ma różnicy z punktu widzenia wydajności i kodu generowanego. W testach wydajności szły tam iz powrotem, między którymi jeden był szybszy w porównaniu z drugim, i tylko o milisekundy.

Patrząc na kod zza kulis, naprawdę nie widzisz żadnej różnicy. Jedyną różnicą jest IL, który string.Empty używa kodu opcode ldsfld i "" używa kodu opcode ldstr, ale dzieje się tak tylko dlatego, że string.Empty jest statyczna i obie instrukcje robią to samo. Jeśli spójrz na zespół, który jest produkowany, jest dokładnie taki sam.

C# Code

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

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

Kod IL

.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

Kod montażu

        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 

Najlepszy kod to brak kodu :

Podstawową naturą kodowania jest to, że naszym zadaniem, jako programistów, jest uznanie, że każda decyzja, którą podejmujemy, jest kompromisem. [ ... ] zacznij od zwięzłości. Zwiększ inne wymiary zgodnie z wymaganiami testowymi.

W związku z tym mniej kodu jest lepszym kodem: preferuj "" do string.Empty lub String.Empty. Te dwa są sześć razy dłuższe BEZ dodatkowych korzyści-z pewnością bez dodatkowej jasności, ponieważ wyrażają dokładną te same informacje.

Jedna różnica polega na tym, że jeśli używasz składni switch-case, nie możesz napisać case string.Empty:, ponieważ nie jest to stała. Otrzymujesz Compilation error : A constant value is expected

Spójrz na ten link, aby uzyskać więcej informacji: string-empty-versus-empty-quotes

Wolę string od String. wybór string.Empty nad "" jest kwestią wyboru jednego i trzymania się go. Zaletą używania string.Empty jest to, że jest to bardzo oczywiste, co masz na myśli, i nie kopiujesz przypadkowo nad niedrukowalnymi znakami, takimi jak "\x003" w twoim "".

Nie chciałem się wtrącać, ale widzę, że ktoś wyrzuca złe informacje.

Jak wspomnieli inni, nie ma żadnej różnicy między string.Empty a String.Empty.

Dodatkowo, i jest to mało znany fakt, używanie "" jest całkowicie dopuszczalne. Każda instancja "" będzie, w innych środowiskach, tworzyć obiekt. Jednak. NET interns swoje ciągi, więc przyszłe instancje będą pobierać ten sam niezmienny ciąg z puli intern, a każdy hit wydajności będzie znikomy. Źródło: Brad Abrams .

Ja osobiście wolę "" chyba, że jest dobry powód do czegoś bardziej złożonego.

String.Empty i string.Empty są równoważne. String jest nazwą klasy BCL; {[3] } jest jej aliasem C# (lub skrótem, jeśli wolisz). Podobnie jak w przypadku Int32 i int. Więcej przykładów można znaleźć w docs.

Jeśli chodzi o "", to nie jestem pewien.

Osobiście zawsze używam string.Empty.

Prawie każdy programista będzie wiedział, co oznacza"". Osobiście natknąłem się na String.Pusty za pierwszym razem i musiał spędzić trochę czasu szukając w google, aby dowiedzieć się, czy naprawdę są Dokładnie to samo.

Ten temat jest dość stary i długi, więc przepraszam, jeśli takie zachowanie zostało wspomniane gdzieś indziej. (I wskaż mi odpowiedź, która obejmuje to)

Znalazłem różnicę w zachowaniu kompilatora, jeśli używasz string.Empty lub podwójnych cudzysłowów. Różnica pojawia się, jeśli nie używasz zmiennej string zainicjalizowanej przez string.Puste lub z podwójnymi cudzysłowami.

W przypadku inicjalizacji za pomocą string.Empty wtedy Ostrzeżenie kompilatora

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

Nigdy nie jest emitowana podczas gdy w w przypadku inicjalizacji podwójnymi cudzysłowami otrzymujemy oczekiwaną wiadomość.

To zachowanie jest wyjaśnione w artykule Connect pod tym linkiem: https://connect.microsoft.com/VisualStudio/feedback/details/799810/c-warning-cs0219-not-reported-when-assign-non-constant-value{[13]

Zasadniczo, jeśli dobrze zrozumiałem, chcą pozwolić programiście ustawić zmienną z wartością zwracaną funkcji do celów debugowania bez zawracania mu głowy komunikatem ostrzegawczym, a tym samym ograniczenie Ostrzeżenia tylko w przypadku zleceń kosztorysowych i ciągów.Empty nie jest stałą, ale polem.

Wykonałem ten bardzo prosty test używając następującej funkcji w aplikacji konsolowej:

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
}

To wyraźnie sugeruje, że wszystkie trzy zmienne mianowicie str1, str2 i str3 chociaż są inicjowane przy użyciu innej składni, ale wskazują dokładnie ten sam łańcuch (o zerowej długości) obiekt w pamięci . Test wykonałem w aplikacji konsolowej. Net 4.5. Więc wewnętrznie nie mają różnicy i wszystko sprowadza się do wygody, który z nich chcesz używać jako programista. To zachowanie klasy string jest znane jako string interning W .Net. Eric Lippert ma bardzo ładny blog tutaj opisujący to pojęcie.

Którekolwiek z powyższych.

Jest wiele, wiele lepszych rzeczy do pontyfikatu. Jaki kolor kora najlepiej pasuje do drzewa, myślę, że mglisty brąz z odcieniami mchu dulcet.

Zdecydowanie wolę Stringi.Puste, oprócz innych powodów, aby upewnić się, że wiesz, co to jest i że nie przypadkowo usunięto zawartość, ale przede wszystkim dla internacjonalizacji. Jeśli widzę ciąg znaków w cudzysłowach, to zawsze muszę się zastanawiać, czy jest to nowy kod i powinien być umieszczony w tabeli łańcuchów. Więc za każdym razem, gdy kod zostanie zmieniony/przejrzany, musisz szukać "czegoś w cudzysłowach" i tak, możesz odfiltrować puste ciągi, ale mówię ludziom, że dobrą praktyką jest nigdy nie umieszczać łańcuchy w cudzysłowach, chyba że wiesz, że nie zostaną zlokalizowane.

Nikt nie wspomniał, że w VisualStudio String jest kodowany inaczej niż string. Co jest ważne dla czytelności. Ponadto małe litery są zwykle używane dla var I type, nie jest to wielka sprawa, ale String.Empty jest stałą, a nie var lub type.

Nie robię różnicy. Ostatni jest najszybszy do wpisania:)

string jest synonimem typu System.String, są identyczne.

Wartości są również identyczne: string.Empty == String.Empty == ""

Nie użyłbym stałej znakowej "" w kodzie, raczej string.Empty lub String.Empty - łatwiej zobaczyć, co programista miał na myśli.

Pomiędzy string a String lubię małe litery string bardziej tylko dlatego, że pracowałem z Delphi przez wiele lat, a styl Delphi to małe litery string.

Więc gdybym był twoim szefem, napisałbyś string.Empty

To nie ma znaczenia - to dokładnie to samo. Jednak najważniejsze jest to, że musi być konsekwentny

P. S.cały czas zmagam się z tego typu "co jest słuszne".

Używam trzeciego, ale z dwóch pozostałych pierwszy wydaje się mniej dziwny. string jest aliasem dla String, ale oglądanie ich przez zadanie wydaje się być wyłączone.

Jedna z dwóch pierwszych byłaby dla mnie do przyjęcia. Uniknąłbym tego ostatniego, ponieważ stosunkowo łatwo jest wprowadzić błąd, umieszczając spację między cudzysłowami. Ten konkretny błąd byłby trudny do znalezienia przez obserwację. Zakładając brak literówek, wszystkie są semantycznie równoważne.

[edytuj]

Możesz też zawsze używać string LUB String dla spójności, ale to tylko ja.

Jest to całkowicie preferencja stylu kodu, do tego, jak. NET obsługuje ciągi. Jednak oto moje opinie:)

Zawsze używam nazw typów BCL przy dostępie do statycznych metod, właściwości i pól: String.Empty LUB Int32.TryParse(...) lub Double.Epsilon

Zawsze używam słów kluczowych C# przy deklarowaniu nowych instancji: int i = 0; lub string foo = "bar";

Rzadko używam niezgłoszonych liter ciągów, ponieważ lubię być w stanie zeskanować kod, aby połączyć je w wielokrotnego użytku nazwane stałe. Kompilator zastępuje stałe literały w każdym razie więc jest to bardziej sposób na uniknięcie magicznych ciągów / liczb i nadanie im trochę większego znaczenia za pomocą nazwy. Dodatkowo zmiana wartości jest łatwiejsza.

Osobiście byłem świadkiem "" powodujących (drobne) problemy dwa razy. Raz było to spowodowane błędem młodszego programisty nowego w Programowaniu Zespołowym, a drugi był prostą literówką, ale faktem jest, że używa się ciągu.Empty uniknąłby obu problemów.

Tak, jest to bardzo osąd, ale kiedy język daje Ci wiele sposobów na robienie rzeczy, skłaniam się ku temu, który ma największy nadzór nad kompilatorem i najsilniejsze egzekwowanie czasu kompilacji. To jest NIE "". Chodzi o wyrażanie konkretnych intencji.

Jeśli wpiszesz string.Pusty lub Strng.Pusty, kompilator daje Ci znać, że zrobiłeś to źle. Natychmiast. Po prostu się nie skompiluje. Jako programista cytujesz konkretną intencję, że kompilator (lub inny deweloper) nie może w żaden sposób źle zinterpretować, a gdy zrobisz to źle, nie możesz utworzyć błędu.

Jeśli wpiszesz ""kiedy masz na myśli "" lub odwrotnie, kompilator z radością zrobi to, co mu kazałeś. Inny deweloper może lub może nie być w stanie zebrać swoich konkretnych intencji. Bug created.

Long before string.Empty było czymś, czego użyłem standardowej biblioteki, która zdefiniowała stałą EMPTY_STRING. Nadal używamy tej stałej w poleceniach case, gdzie string.Puste nie jest dozwolone.

Jeśli to możliwe, umieść kompilator w pracy dla Ciebie i wyeliminuj możliwość błędu ludzkiego, bez względu na to, jak mały. IMO to przebija "czytelność", jak cytowali inni.

Specyfika i egzekwowanie czasu kompilacji. On co na obiad.

Wolałbym string.Empty zamiast String.Empty, ponieważ możesz go użyć bez konieczności dołączania using System; do swojego pliku.

Kompilator powinien uczynić je wszystkie takimi samymi na dłuższą metę. Wybierz standard, aby Twój kod był łatwy do odczytania i trzymaj się go.

Właśnie patrzyłem na jakiś kod i to pytanie przyszło mi do głowy, które czytałem jakiś czas wcześniej. Jest to z pewnością kwestia czytelności.

Rozważ następujący kod C#...

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

Vs

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

Jak zauważyli inni, rzeczywiste różnice są znikome.

Używam "", ponieważ w moim kodzie będzie ono wyraźnie żółte... z jakiegoś powodu String.Empty jest cały biały w moim motywie Visual Studio Code. I wierzę, że to ma dla mnie największe znaczenie.

Myślę, że druga jest "właściwa", ale szczerze mówiąc nie sądzę, że to będzie miało znaczenie. Kompilator powinien być wystarczająco inteligentny, aby skompilować dowolny z nich do dokładnie tego samego bajtowego kodu. Sam używam "".

On http://blogs.msdn.com/b/brada/archive/2003/04/22/49997.aspx:

Jak sugeruje David, różnica między String.Empty i "" jest dość mała, ale jest różnica. "" rzeczywiście tworzy obiekt, prawdopodobnie zostanie wyciągnięty z puli ciągów, ale nadal... while String.Empty nie tworzy żadnego obiektu... więc jeśli naprawdę szukasz wydajności pamięci, proponuję String.Empty. Należy jednak pamiętać, że różnica jest tak trival będzie jakby nigdy nie było tego w Twoim kodzie...
Dla System.String.Empty lub string.Empty lub String.Empty... mój poziom opieki jest niski; -)

Pusty łańcuch jest jak pusty zbiór tylko nazwą, której każdy używa do wywołania "". Również w językach formalnych ciągi utworzone z alfabetu, które mają zerową długość, nazywane są ciągiem pustym. Zarówno set, jak i string mają dla niego specjalny symbol. Pusty ciąg: ε i pusty zestaw:∅. Jeśli chcesz mówić o tym Ciągu o zerowej długości, nazwiesz go pustym ciągiem, aby każdy wiedział dokładnie, do czego się odnosisz. Teraz w przypadku nazwania go pustym ciągiem, dlaczego nie użyć string.Empty w kodzie, jego pokazuje intencja jest jednoznaczna. Minusem jest to, że nie jest stała i dlatego nie jest dostępna wszędzie, jak w atrybutach. (Nie jest to stała z pewnych powodów technicznych, patrz źródło odniesienia.)

Chociaż różnica jest bardzo, bardzo mała, różnica nadal istnieje.

1) "" wytworzy obiekt while String.Pusty nie. Ale ten obiekt zostanie utworzony raz i będzie odwoływany z puli łańcuchów później, jeśli masz inny "" w kodzie.

2) String i string są takie same, ale polecam użyć String.Empty (a także String.Format, Ciąg.Kopiowanie itp.) ponieważ notacja kropkowa wskazuje klasę, A nie operator, a posiadanie klasy zaczynającej się wielką literą jest zgodne z Standardy kodowania C#.