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

705

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?

Daniel Kreiseder
quelle
7
Siehe auch diese ähnliche Diskussion für Java: stackoverflow.com/questions/213985/…
harpo
39
Es ist jedoch besser, String.IsNullOrEmpty (String myString) zu verwenden.
ZombieSheep
3
Ich benutze [string.IsNullOrWhiteSpace (stringvalue)] ... funktioniert in .Net 4.0. Zum Initialisieren benutze ich einfach: [var text = "";] Einfach, lesbar und benötigt am wenigsten Zeit zum
Tippen
61
Was wichtiger ist, ist der lustige Name Ihrer Variablen.
Arj
5
Was mich interessiert hat, ist, warum es überhaupt eine leere Immobilie gibt. Es ist schön und alles, aber kein notwendiges und komplettes Muss.
MasterMastic

Antworten:

807

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.

Jon Skeet
quelle
75
Ihre Augen können Sie austricksen, wenn Sie erwarten, "" zu sehen, können Sie leicht "" mit "" verwechseln. Aus diesem Grund ist es einfacher, etwas zu bearbeiten, das jemand anderes geschrieben hat. Ihr Gehirn hat keine vorgefassten Vorstellungen über den Text, daher ist es einfacher, die Anomalien herauszufinden.
Tvanfosson
125
@tvanfosson: Wurden Sie (oder ein Kollege) tatsächlich als Fehler davon gebissen? Ich bin dieser Art von Behauptung misstrauisch, ohne dass sie tatsächlich Probleme verursacht hat. Ich benutze "" seit Jahren, ohne es jemals falsch
Jon Skeet
34
Persönlich habe ich immer String verwendet. Leer, ich verwende Großbuchstaben 'S', wenn ich eine statische Methode für Zeichenfolgen verwenden möchte. Es ist nur eine persönliche Präferenz, mit der ich einen Typ von einer Variablen unterscheiden kann. Dies ist jedoch nur eine Übertragung der Verwendung von StringUtils.EMPTY in commons.lang aus Java. Ein Punkt von Interesse ist, dass ich fast blind bin und dies definitiv die Lesbarkeit für mich verbessert.
Brett Ryan
79
Sie haben mir die Inspiration gegeben, mich in Times New Roman zu entwickeln.
Justin Rusbatch
73
Aus irgendeinem obskuren Grund string.Emptyist keine Konstante . Das bedeutet, dass in einigen Fällen, in denen eine Konstante für die Kompilierungszeit erforderlich string.Emptyist, nicht einmal legal ist. Dies umfasst case ""Blöcke in switchAnweisungen, Standardwerte für optionale Parameter , Parameter und Eigenschaften beim Anwenden von Attributen und viele andere Situationen (dem Leser überlassen). Da dies string.Emptyin einigen häufigen Situationen nicht ""zulässig ist, ist es besser, die Konvention -everywhere zu verwenden.
Jeppe Stig Nielsen
375

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 
aBetterGamer
quelle
13
@PrateekSaluja: Um die IL anzuzeigen, können Sie ildasm.exe verwenden, das im Lieferumfang von Visual Studio enthalten ist. Verwenden Sie das Fenster 'Disassembly' im Debug-Menü, wenn Sie einen Haltepunkt erreichen (funktioniert auch im Release-Code), um die Demontage anzuzeigen.
Thomas Bratt
1
Ich hasse es, dieses Produkt zu empfehlen. ABER mit dem Reflektor können Sie Ihre Sprache auswählen, wenn Sie die Quelle zerlegen, und IL ist eine Option! ILDASM ist nur ein veraltetes Gefühl ... Das MS Tools Team scheint die guten Tools nicht zu polieren oder freizugeben!
Felickz
80

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.

Konrad Rudolph
quelle
1
aber in C # können wir nur string.IsNullOrWhitespace (s) sagen: p
felickz
31
Ich bin damit einverstanden, dass Code so klein wie möglich sein sollte, würde aber im Allgemeinen nicht argumentieren, dass weniger Zeichen immer besserer Code sind. Wenn es zum Beispiel um die Benennung von Variablen geht, führt eine angemessene Anzahl von Zeichen im Allgemeinen zu besseren Namen als nur die Verwendung von i und j.
Markus Meyer
3
@Markus Das hängt stark davon ab: Für eine Schleifenvariable, die einen Index darstellt, i ist sie besser als ein langer Variablenname. Noch allgemeinere, kürzere Variablennamen , die die gleichen Informationen in der gleichen Klarheit vermitteln, sind immer vorzuziehen. Es ist nur so, dass Sie eine bestimmte Zeichenlänge benötigen , um die erforderlichen Informationen auszudrücken , und ich leugne dies nicht (niemand ist es).
Konrad Rudolph
2
@Konrad: i ist nur dann ein guter Variablenname, wenn die Schleife klein ist und keine anderen Indizes enthält. Aber ich stimme zu, wenn etw. kann kurz angegeben werden, um die gleichen Informationen zu übermitteln, die vorzuziehen wären, wie im Fall string.Empty / "". Der string.Empty fügt keine Klarheit hinzu.
Markus Meyer
Für mich: string.Empty sagt, dass dieser String jederzeit leer ist und sein sollte, während "" sagt, dass dieser String zum Zeitpunkt des Schreibens leer sein könnte, Sie ihn aber jederzeit ändern können.
Aeroson
54

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

Mentoliptus
quelle
22
Die switchAussage ist ein sehr gutes Beispiel. Wenn Sie beispielsweise einen optionalen Parameter festlegen void MyMethod(string optional = "") { ... }, ist die Verwendung ebenfalls nicht möglich string.Empty. Und wenn Sie dann natürlich ein constFeld oder eine lokale Variable definieren möchten , ist dies const string myString = "";wiederum ""die einzige Option. Wenn nur string.Emptyein konstantes Feld wäre, gäbe es keinen Unterschied. Aber es ist nicht so, also müssen Sie in einigen Fällen verwenden "". Warum also nicht die ""ganze Zeit nutzen?
Jeppe Stig Nielsen
5
Dies ist ein wirklich starkes Argument, da die Verwendung string.Emptyverhindert , dass Sie Konsistenz in Ihrer Codebasis erreichen: Sie müssen zwei verschiedene Entitäten verwenden, um dasselbe auszudrücken. Und um der Liste der Dinge hinzuzufügen, die Sie nicht tun können: Sie können nicht string.Emptymit Attributen verwenden .
Pragmateek
2
Sehr gute Punkte! Die Verbindung ist unterbrochen. Hier ist eine Kopie des Inhalts: web.archive.org/web/20131230161806/http://kossovsky.net/…
ygoe
42

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 "".

Jimmy
quelle
101
Ich würde behaupten, wenn Sie versehentlich nicht druckbare Zeichen in Ihren Code kopieren, haben Sie größere Probleme als diese Frage;)
Jon Skeet
9
ASCII \ 003 ist zufällig ein Feldtrennzeichen für B2B-Nachrichten, mit denen ich gearbeitet habe :)
Jimmy
7
(Ich würde übrigens auch vorschlagen, die \ x-Flucht zu vermeiden - es ist zu schwer, den Unterschied zwischen "\ x9Bad Compiler" und "\ x9Good Compiler" zu erkennen radikal unterschiedliche Ergebnisse haben!)
Jon Skeet
Persönlich bevorzuge ich String gegenüber String, wenn ich eine statische Methode für String aufrufe. Ich bin jedoch fast blind und dies ist eine persönliche Präferenz, die ich niemandem aufzwinge.
Brett Ryan
2
@ Jimmy Sicher, aber wir haben über die leere Zeichenfolge gesprochen. Das Argument, ""das beim Kopieren / Einfügen gefährlich ist, ist nichtig, weil Sie die leere Zeichenfolge niemals kopieren / einfügen. Für andere Saiten ist es natürlich immer etwas zu beachten.
Timo
22

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 .

John Rudy
quelle
20
Ich verstehe nicht, warum "technisch" jede Instanz von "" ein Objekt erstellt. Es ist nicht nur ein Zufall, dass Zeichenfolgen interniert werden - es ist in der C # -Spezifikation.
Jon Skeet
15

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

MidnightGun
quelle
13

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.

Silviu Niculita
quelle
10

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.

Jason Baker
quelle
3
Es ist ein öffentliches schreibgeschütztes Zeichenfolgenfeld und seine Werte sind "" ... warum sollte sich das ändern?
Matthew Whited
5
Sie verpassen den Punkt, den @Jason macht. Woher weißt du, was du zum ersten Mal siehst string.Empty? Wussten Sie, was Sie ""zum ersten Mal gesehen haben?
David R Tribble
10

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.

Steve
quelle
1
Ich glaube, du bist der erste, der es erwähnt. Ich habe diese Fragen und Antworten vor einigen Monaten gelesen und erinnere mich nicht an diesen Unterschied, den ich hätte, wenn er erwähnt worden wäre.
Palec
2
Interessant. Beachten Sie, dass eine Deklaration var unused = "literal";vom Compiler vollständig optimiert (entfernt) werden kann. Es kann keine Nebenwirkungen haben. Andererseits var unused = MyClass.Member;kann nicht vollständig entfernt werden. Das liegt daran, dass das Lesen MemberNebenwirkungen haben kann. Wenn Memberes sich um eine statische Eigenschaft mit einem getAccessor handelt, ist klar, dass der Aufruf des Getters beibehalten werden muss. Aber selbst wenn Memberes sich um ein statisches Feld handelt, kann der statische Konstruktor möglicherweise den Nebeneffekt ausführen. Sicher wäre es ein schlechter Codierungsstil , wenn es so wäre. Aber du brauchst einen Dummy zum Lesen Member.
Jeppe Stig Nielsen
9

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.

RBT
quelle
8

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.

Streit
quelle
7

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 .


quelle
7

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.

Dimitry
quelle
String.Empty ist keine Konstante: siehe stackoverflow.com/questions/507923/… Es handelt sich tatsächlich um eine Instanz der String-Klasse. Und Färbung wurde bereits erwähnt, wenn auch etwas versteckt: stackoverflow.com/questions/263191/…
Michael
6

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

Zendar
quelle
6

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.

Andrew
quelle
2
Ich bin das einzige Mitglied des Teams. Wie entscheide ich mich? werfe einen Würfel?
Gqqnbig
1
Für diejenigen, die sich fragen, wie es möglich ist, string.EmptyKonstanten zu verwenden, ohne einen using SystemNamespace zu importieren - Schlüsselwörter in C # werden einfach in ihren vollständig qualifizierten Namen konvertiert, der auch den Namespace enthält, bevor sie als MSIL in die Ausgabe * .dll oder * geschrieben werden. exe-Datei. Wird also effektiv string.Emptywie System.String.Emptyin der MSIL vom Compiler geschrieben. Und da Sie vielleicht bereits wissen, dass Sie, wenn Sie einen vollständig qualifizierten Typnamen erwähnen, den Import von Namespaces oben in Ihrer Codedatei überspringen können.
RBT
5

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


quelle
4

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?".

Calanus
quelle
1
In der modernen Welt bedeutet "konsistent" konsistent in allen Teams weltweit, was eines der Ziele von StackOverflow ist. Wenn ich vorschlagen darf, verwenden wir String.Empty.
Pavel Radzivilovsky
1
Einige Sprachen haben keine leere Konstante, und alle Sprachen, die ich mir vorstellen kann, erlauben eine Zeichenfolge mit der Länge Null. Deshalb stimme ich für "", um die Übereinstimmung mit anderen Sprachen zu gewährleisten. :)
TomXP411
4

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.

mckamey
quelle
3

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.

Sockel
quelle
3

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.

Tvanfosson
quelle
Ich stimme dieser Bemerkung zu, aber ich lebe immer noch gefährlich, wenn ich faul bin. Auf jeden Fall glaube ich nicht, dass ich Gelegenheit habe, Code zu schreiben, der eine Zeichenfolge verwendet, bevor ich sie außerhalb der Variablendeklaration zuweise. Tatsächlich ist es für mich ärgerlich, dass ich meine Saiten trotz der Risiken überhaupt initialisieren muss.
EnocNRoll - AnandaGopal Pardue
3

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.

RhinoTX
quelle
3

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.

5argon
quelle
2

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.

Chris Marasti-Georg
quelle
2

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.

Remotec
quelle
1

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.

Magus
quelle
1

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.

user34577
quelle
1
string.Empty is "", überprüfen Sie die Quelle
dss539
1

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 ;-)

Sergiol
quelle
1
Dieser MSDN-Blogbeitrag wurde 2003 veröffentlicht. Sind Sie sicher, dass dies für aktuelle .NET-Versionen immer noch gilt?!
Carsten Schütte
@ CarstenSchütte: Mir scheint, dass sich an einer solchen Funktion nicht viel ändern soll ... und wenn ja, gab es im Internet einige Begeisterung darüber.
Sergiol
3
@sergiol Wenn ein Feld effizienter als ein Literal ist, ist dies eindeutig ein Leistungsfehler. Es besteht also die Hoffnung, dass es jetzt behoben ist.
Konrad Rudolph
1

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.)

Wouter
quelle
0

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

Anders Lindén
quelle