Sollte ich in C # string.Empty oder String.Empty oder "" verwenden, um einen String zu initialisieren?

In C # möchte ich einen Zeichenfolgenwert mit einer leeren Zeichenfolge initialisieren.

Wie soll ich das machen? Was ist der richtige Weg und warum?

string willi = string.Empty;

oder

string willi = String.Empty;

oder

string willi = "";

oder was?

Verwenden Sie alles, was Sie und Ihr Team am besten lesen können.

Andere Antworten deuten darauf hin, dass bei jeder Verwendung eine neue Zeichenfolge erstellt wird "". Dies ist nicht der Fall - aufgrund der internen Zeichenfolge wird es entweder einmal pro Assembly oder einmal pro AppDomain erstellt (oder möglicherweise einmal für den gesamten Prozess - diesbezüglich nicht sicher). Dieser Unterschied ist vernachlässigbar - massiv, massiv unbedeutend.

Was Sie besser lesbar finden, ist jedoch eine andere Sache. Es ist subjektiv und wird von Person zu Person unterschiedlich sein. Ich schlage vor, Sie finden heraus, was die meisten Leute in Ihrem Team mögen, und alle gehen aus Gründen der Konsistenz damit um. Persönlich finde ich ""leichter zu lesen.

Das Argument, dass ""und " "leicht miteinander verwechselt werden, wäscht sich nicht wirklich mit mir. Sofern Sie eine proportionale Schriftart verwenden (und ich habe nicht gearbeitet allen Entwicklern , die tun) , ist es ziemlich einfach zu sagen , der Unterschied.

Es gibt wirklich keinen Unterschied in Bezug auf Leistung und Code. Bei Leistungstests gingen sie hin und her, wobei einer schneller als der andere war und nur Millisekunden.

Wenn Sie sich den Code hinter den Kulissen ansehen, sehen Sie auch keinen Unterschied. Der einzige Unterschied besteht in der IL, die string.Emptyden Opcode verwendet ldsfld und ""den Opcode verwendet ldstr, aber das liegt nur daran, dass er string.Emptystatisch ist und beide Anweisungen dasselbe tun. Wenn Sie sich die produzierte Baugruppe ansehen, ist sie genau dieselbe.

C # -Code

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

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

IL-Code

.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

Baugruppencode

        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 

Der beste Code ist überhaupt kein Code :

Die grundlegende Natur der Codierung besteht darin, dass unsere Aufgabe als Programmierer darin besteht, zu erkennen, dass jede Entscheidung, die wir treffen, ein Kompromiss ist. […] Beginnen Sie mit der Kürze. Erhöhen Sie die anderen Abmessungen nach Bedarf durch Testen.

Folglich weniger Code ist besser Code: Bevorzugen ""zu string.Emptyoder String.Empty. Diese beiden sind sechsmal länger ohne zusätzlichen Nutzen - sicherlich ohne zusätzliche Klarheit, da sie genau die gleichen Informationen ausdrücken.

Ein Unterschied besteht darin, dass Sie bei Verwendung einer switch-caseSyntax nicht schreiben können, case string.Empty:da es sich nicht um eine Konstante handelt. Du bekommst einCompilation error : A constant value is expected

Weitere Informationen finden Sie unter diesem Link: Zeichenfolge-leer-gegen-leer-Anführungszeichen

Ich würde es vorziehen stringzu String. Wahl string.Emptyüber ""eine Angelegenheit von der Wahl ein und mit ihm kleben. Der Vorteil der Verwendung string.Emptyist, dass es sehr offensichtlich ist, was Sie meinen, und dass Sie nicht versehentlich über nicht druckbare Zeichen wie "\x003"in Ihrem kopieren "".

Ich wollte mich nicht einmischen, aber ich sehe einige falsche Informationen, die hier rausgeworfen werden.

Ich persönlich bevorzuge string.Empty. Das ist eine persönliche Präferenz, und ich beuge mich dem Willen jedes Teams, mit dem ich von Fall zu Fall zusammenarbeite.

Wie einige andere erwähnt haben, gibt es überhaupt keinen Unterschied zwischen string.Emptyund String.Empty.

Zusätzlich, und dies ist eine wenig bekannte Tatsache, ist die Verwendung von "" vollkommen akzeptabel. Jede Instanz von "" erstellt in anderen Umgebungen ein Objekt. .NET interniert jedoch seine Zeichenfolgen, sodass zukünftige Instanzen dieselbe unveränderliche Zeichenfolge aus dem internen Pool ziehen und jeder Leistungseinbruch vernachlässigbar ist. Quelle: Brad Abrams .

Ich persönlich bevorzuge "", es sei denn, es gibt einen guten Grund für etwas Komplexeres.

String.Emptyund string.Emptysind gleichwertig. Stringist der BCL-Klassenname; stringist der C # -Alias ​​(oder die Verknüpfung, wenn Sie so wollen). Gleich wie mit Int32und int. Siehe die DokumenteWeitere Beispiele finden .

So weit wie "" betrifft, so bin ich nicht wirklich sicher.

Persönlich benutze ich immer string.Empty.

Nahezu jeder Entwickler weiß, was "" bedeutet. Ich persönlich String.Empty das erste Mal begegnet und hatte einige Zeit Google - Suche , um herauszufinden , verbringen , wenn sie wirklich sind genau die gleiche Sache.

Dieses Thema ist ziemlich alt und lang, also entschuldigen Sie, wenn dieses Verhalten woanders erwähnt wurde. (Und zeigen Sie mir die Antwort, die dies abdeckt)

Ich habe einen Unterschied im Verhalten des Compilers festgestellt, wenn Sie string.Emptydoppelte Anführungszeichen verwenden. Der Unterschied zeigt sich, wenn Sie die mit string.Empty oder in doppelten Anführungszeichen initialisierte Zeichenfolgenvariable nicht verwenden.

Im Falle einer Initialisierung mit string.Emptyder Compiler-Warnung

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

wird niemals ausgegeben, während bei einer Initialisierung mit doppelten Anführungszeichen die erwartete Nachricht angezeigt wird.

Dieses Verhalten wird im Connect-Artikel unter diesem Link erläutert: https://connect.microsoft.com/VisualStudio/feedback/details/799810/c-warning-cs0219-not-reported-when-assign-non-constant-value

Wenn ich es richtig verstehe, möchten sie einem Programmierer grundsätzlich erlauben, eine Variable mit dem Rückgabewert einer Funktion für Debugging-Zwecke festzulegen, ohne ihn mit einer Warnmeldung zu belästigen, und sie haben die Warnung daher nur bei kostenpflichtigen Zuweisungen und Zeichenfolgen eingeschränkt. Leer ist keine Konstante, sondern ein Feld.

Ich habe diesen sehr einfachen Test mit der folgenden Methode in einer Konsolenanwendung durchgeführt:

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
}

Dies zeigt eindeutig , dass alle drei Variablen nämlich str1, str2und str3obwohl andere Syntax auf die genau gleiche Zeichenfolge im Speicher (der Länge Null) Objekt verweisen unter Verwendung initialisiert wird. Ich habe diesen Test in der .NET 4.5-Konsolenanwendung durchgeführt. Intern haben sie also keinen Unterschied und es läuft alles auf die Bequemlichkeit hinaus, welche Sie als Programmierer verwenden möchten. Dieses Verhalten der Zeichenfolgenklasse wird als Zeichenfolgeninternierung in .NET bezeichnet. Eric Lippert hat hier einen sehr schönen Blog , der dieses Konzept beschreibt.

Eine der oben genannten.

Es gibt viele, viele bessere Dinge zu pontifizieren. Zum Beispiel, welche Farbe Rinde am besten zu einem Baum passt, denke ich, dass sie vage braun mit einem Hauch von Dulcet-Moos ist.

Ich bevorzuge String.Empty, abgesehen von den anderen Gründen, um sicherzustellen, dass Sie wissen, was es ist und dass Sie den Inhalt nicht versehentlich entfernt haben, sondern hauptsächlich für die Internationalisierung. Wenn ich eine Zeichenfolge in Anführungszeichen sehe, muss ich mich immer fragen, ob dies neuer Code ist und in eine Zeichenfolgentabelle eingefügt werden sollte. Jedes Mal, wenn Code geändert / überprüft wird, müssen Sie nach "etwas in Anführungszeichen" suchen, und ja, Sie können die leeren Zeichenfolgen herausfiltern, aber ich sage den Leuten, dass es eine gute Praxis ist, Zeichenfolgen niemals in Anführungszeichen zu setzen, es sei denn, Sie wissen, dass sie nicht lokalisiert werden .

Niemand erwähnte, dass String in VisualStudio anders farblich gekennzeichnet ist als String. Welches ist wichtig für die Lesbarkeit. Außerdem wird normalerweise Kleinbuchstaben für vars und type verwendet, keine große Sache, aber String.Empty ist eine Konstante und keine var oder type.

string ist synonym für System.String Typ. Sie sind identisch.

Die Werte sind ebenfalls identisch: string.Empty == String.Empty == ""

Ich würde nicht Zeichen - Konstante „“ im Code verwenden, eher string.Emptyoder String.Empty- einfacher zu sehen , was Programmierer gedacht.

Zwischen stringund Stringich mag Kleinbuchstaben stringmehr, nur weil ich viele Jahre mit Delphi gearbeitet habe und der Delphi-Stil Kleinbuchstaben iststring .

Wenn ich Ihr Chef wäre, würden Sie schreiben string.Empty

Ich würde bevorzugen string.Emptyüber , String.Emptyweil Sie es , ohne dass verwenden kann ein schließenusing System; , in Ihrer Datei.

Wie für die Kommissionierung ""über string.Empty, ist es persönliche Präferenz und soll von Ihrem Team entschieden werden.

Ich mache keinen Unterschied. Der letzte ist der am schnellsten zu tippende :)

Es spielt keine Rolle - sie sind genau das gleiche. Die Hauptsache ist jedoch, dass Sie konsequent sein müssen

ps Ich kämpfe die ganze Zeit mit dieser Art von "Was ist das Richtige?".

Es ist eine Vorliebe für den Codestil, wie .NET mit Zeichenfolgen umgeht. Hier sind jedoch meine Meinungen :)

Ich verwende immer die BCL-Typnamen, wenn ich auf statische Methoden, Eigenschaften und Felder zugreife: String.EmptyoderInt32.TryParse(...) oderDouble.Epsilon

Ich verwende immer die C # -Schlüsselwörter, wenn ich neue Instanzen deklariere: int i = 0; oderstring foo = "bar";

Ich verwende selten nicht deklarierte String-Literale, da ich den Code scannen möchte, um sie zu wiederverwendbaren benannten Konstanten zu kombinieren. Der Compiler ersetzt Konstanten sowieso durch die Literale, so dass dies eher eine Möglichkeit ist, magische Zeichenfolgen / Zahlen zu vermeiden und ihnen mit einem Namen etwas mehr Bedeutung zu geben. Außerdem ist das Ändern der Werte einfacher.

Ich benutze die dritte, aber von den anderen beiden scheint die erste weniger seltsam. string ist ein Alias ​​für String, aber es fühlt sich nicht gut an, sie in einer Zuweisung zu sehen.

Jeder der ersten beiden wäre für mich akzeptabel. Ich würde den letzten vermeiden, da es relativ einfach ist, einen Fehler einzuführen, indem ein Leerzeichen zwischen die Anführungszeichen gesetzt wird. Dieser spezielle Fehler wäre durch Beobachtung schwer zu finden. Unter der Annahme, dass keine Tippfehler vorliegen, sind alle semantisch äquivalent.

[BEARBEITEN]

Vielleicht möchten Sie auch immer entweder stringoder Stringaus Gründen der Konsistenz verwenden, aber das bin nur ich.

Ich habe persönlich "" gesehen, was zweimal zu (geringfügigen) Problemen führte. Einmal war dies auf einen Fehler eines Junior-Entwicklers zurückzuführen, der neu in der teambasierten Programmierung war, und der andere war ein einfacher Tippfehler, aber die Tatsache ist die Verwendung von string.Empty hätte beide Probleme vermieden.

Ja, dies ist in hohem Maße ein Urteilsspruch, aber wenn eine Sprache Ihnen mehrere Möglichkeiten bietet, Dinge zu tun, neige ich dazu, mich zu derjenigen zu neigen, die die größte Compiler-Kontrolle und die stärkste Durchsetzung während der Kompilierungszeit hat. Das ist nicht "". Es geht darum, bestimmte Absichten auszudrücken.

Wenn Sie string.EMpty oder Strng.Empty eingeben, teilt Ihnen der Compiler mit, dass Sie es falsch gemacht haben. Sofort. Es wird einfach nicht kompiliert. Als Entwickler zitieren Sie bestimmte Absicht, die der Compiler (oder ein anderer Entwickler) in keiner Weise falsch interpretieren kann, und wenn Sie es falsch machen, können Sie keinen Fehler erstellen.

Wenn Sie "" eingeben, wenn Sie "" meinen, oder umgekehrt, macht der Compiler glücklich, was Sie ihm gesagt haben. Ein anderer Entwickler kann möglicherweise Ihre spezifische Absicht ermitteln oder nicht. Fehler erstellt.

Lange vor string.Empty habe ich eine Standardbibliothek verwendet, die die Konstante EMPTY_STRING definiert hat. Wir verwenden diese Konstante weiterhin in case-Anweisungen, in denen string.Empty nicht zulässig ist.

Wenn immer möglich, lassen Sie den Compiler für Sie arbeiten und beseitigen Sie die Möglichkeit menschlicher Fehler, egal wie klein sie sind. IMO, dies übertrumpft "Lesbarkeit", wie andere zitiert haben.

Spezifität und Durchsetzung der Kompilierungszeit. Es ist was zum Abendessen.

Ich verwende "", weil es in meinem Code deutlich gelb gefärbt ist ... aus irgendeinem Grund ist String.Empty in meinem Visual Studio-Code-Design ganz weiß. Und ich glaube, das ist mir am wichtigsten.

Der Compiler sollte sie auf lange Sicht alle gleich machen. Wählen Sie einen Standard, damit Ihr Code leicht zu lesen ist, und bleiben Sie dabei.

Ich habe mir nur einen Code angesehen und diese Frage kam mir in den Sinn, die ich einige Zeit zuvor gelesen hatte. Dies ist sicherlich eine Frage der Lesbarkeit.

Betrachten Sie den folgenden C # -Code ...

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

vs.

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

Ich persönlich finde letzteres weniger mehrdeutig und leichter zu lesen.

Wie von anderen hervorgehoben, sind die tatsächlichen Unterschiede vernachlässigbar.

Ich denke, die zweite ist "richtig", aber um ehrlich zu sein, denke ich nicht, dass es wichtig sein wird. Der Compiler sollte intelligent genug sein, um alle mit genau demselben Bytecode zu kompilieren. Ich benutze "" mich.

Obwohl der Unterschied sehr, sehr gering ist, besteht der Unterschied immer noch.

1) "" erstellt ein Objekt, während String.Empty dies nicht tut. Dieses Objekt wird jedoch einmal erstellt und später aus dem Zeichenfolgenpool referenziert, wenn Sie ein anderes "" im Code haben.

2) String und String sind gleich, aber ich würde empfehlen, String.Empty (sowie String.Format, String.Copy usw.) zu verwenden, da die Punktnotation eine Klasse angibt, keinen Operator, und eine Klasse, die mit einem Großbuchstaben beginnt, entspricht C # -Codierungsstandards.

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

Wie David andeutet, gibt es einen Unterschied zwischen String.Emptyund ""sind ziemlich klein, aber es gibt einen Unterschied. Wenn ""tatsächlich ein Objekt erstellt wird, wird es wahrscheinlich aus dem internen Pool der Zeichenfolge herausgezogen, aber dennoch ... während String.Emptykein Objekt erstellt wird ... Wenn Sie also wirklich nach Speichereffizienz suchen, schlage ich vor String.Empty. Sie sollten jedoch bedenken, dass der Unterschied so gering ist, dass Sie ihn gerne nie in Ihrem Code sehen werden ...
Was System.String.Emptyoder string.Emptyoder String.Empty... meine Pflege ist niedrig ;-)

Die leere Zeichenfolge ist wie eine leere Menge, nur ein Name, den jeder zum Aufrufen verwendet "". Auch in formalen Sprachen werden Zeichenfolgen, die aus einem Alphabet mit der Länge Null erstellt wurden, als leere Zeichenfolge bezeichnet. Sowohl set als auch string haben ein spezielles Symbol. Leere Zeichenfolge: ε und leere Menge: ∅. Wenn Sie über diese Zeichenfolge mit der Länge Null sprechen möchten, nennen Sie sie die leere Zeichenfolge, damit jeder genau weiß, worauf Sie sich beziehen. Wenn Sie nun die leere Zeichenfolge nennen, warum nicht string.Emptyim Code verwenden, zeigt dies, dass die Absicht explizit ist. Nachteil ist, dass es keine Konstante ist und daher nicht überall verfügbar ist, wie in Attributen. (Aus technischen Gründen ist es keine Konstante, siehe Referenzquelle.)

Ich bevorzuge, ""weil es kürzer ist und String.Emptyein Problem löst, das es nicht gibt.