Wie führt man ToString für ein möglicherweise null-Objekt aus?

Question

Gibt es einen einfachen Weg, um das Folgende zu tun:

String s = myObj == null ? "" : myObj.ToString();

Ich weiß, dass ich Folgendes tun kann, aber ich betrachte es wirklich als Hack:

String s = "" + myObj;

Es wäre großartig, wenn Convert.ToString() eine ordentliche Überladung dafür hätte.

Answer 1

string s = String.Concat(myObj);

wäre wahrscheinlich der kürzeste Weg und hätte auch vernachlässigbare Leistungseinbußen. Beachten Sie allerdings, dass es für den Leser des Codes nicht ganz klar wäre, was die Absicht ist.

Answer 2

Eigentlich habe ich nicht verstanden, was du tun möchtest. So wie ich es verstehe, kannst du diesen Code anders schreiben. Fragst du das oder nicht? Kannst du mehr erklären?

string s = string.Empty;
    if(!string.IsNullOrEmpty(myObj))
    {
    s = myObj.ToString();
    }

Answer 3

Ich könnte für meine Antwort verprügelt werden, aber hier ist sie trotzdem:

Ich würde einfach schreiben

string s = ""
if (myObj != null) {
   x = myObj.toString();
}

Gibt es einen Leistungsgewinn beim Einsatz des ternären Operators? Ich weiß es nicht aus dem Stegreif.

Und offensichtlich, wie oben erwähnt, kannst du dieses Verhalten in eine Methode wie safeString(myObj) packen, die eine Wiederverwendung ermöglicht.

Answer 4

Ich hatte das gleiche Problem und habe es gelöst, indem ich das Objekt einfach in einen String umgewandelt habe. Dies funktioniert auch für Null-Objekte, da Strings null sein können. Es sei denn, du möchtest absolut keinen null-String haben, sollte dies einwandfrei funktionieren:

string myStr = (string)myObj; // String in einer Objekttarnung oder ein null

Answer 5

Einige (Geschwindigkeits-)Leistungstests, die die verschiedenen Optionen zusammenfassen, nicht dass es wirklich wichtig ist #mikrooptimierung (Verwendung einer linqpad extension)

Optionen

void Main()
{
    object objValue = null;
    test(objValue);
    string strValue = null;
    test(strValue);
}

// Definieren anderer Methoden und Klassen hier
void test(string value) {
    new Perf {
        { "coalesce", n => (value ?? string.Empty).ToString() },
        { "nullcheck", n => value == null ? string.Empty : value.ToString() },
        { "str.Format", n => string.Format("{0}", value) },
        { "str.Concat", n => string.Concat(value) },
        { "string +", n => "" + value },
        { "Convert", n => Convert.ToString(value) },
    }.Vs();
}

void test(object value) {
    new Perf {
        { "coalesce", n => (value ?? string.Empty).ToString() },
        { "nullcheck", n => value == null ? string.Empty : value.ToString() },
        { "str.Format", n => string.Format("{0}", value) },
        { "str.Concat", n => string.Concat(value) },
        { "string +", n => "" + value },
        { "Convert", n => Convert.ToString(value) },
    }.Vs();
}

Wahrscheinlich wichtig zu beachten ist, dass Convert.ToString(...) eine Nullzeichenfolge beibehalten wird.

Ergebnisse

Objekt

• nullcheck 1.00x 1221 Ticks vergangen (0.1221 ms) [in 10K Durchläufen, 1.221E-05 ms pro]
• coalesce 1.14x 1387 Ticks vergangen (0.1387 ms) [in 10K Durchläufen, 1.387E-05 ms pro]
• string + 1.16x 1415 Ticks vergangen (0.1415 ms) [in 10K Durchläufen, 1.415E-05 ms pro]
• str.Concat 1.16x 1420 Ticks vergangen (0.142 ms) [in 10K Durchläufen, 1.42E-05 ms pro]
• Convert 1.58x 1931 Ticks vergangen (0.1931 ms) [in 10K Durchläufen, 1.931E-05 ms pro]
• str.Format 5.45x 6655 Ticks vergangen (0.6655 ms) [in 10K Durchläufen, 6.655E-05 ms pro]

Zeichenkette

• nullcheck 1.00x 1190 Ticks vergangen (0.119 ms) [in 10K Durchläufen, 1.19E-05 ms pro]
• Convert 1.01x 1200 Ticks vergangen (0.12 ms) [in 10K Durchläufen, 1.2E-05 ms pro]
• string + 1.04x 1239 Ticks vergangen (0.1239 ms) [in 10K Durchläufen, 1.239E-05 ms pro]
• coalesce 1.20x 1423 Ticks vergangen (0.1423 ms) [in 10K Durchläufen, 1.423E-05 ms pro]
• str.Concat 4.57x 5444 Ticks vergangen (0.5444 ms) [in 10K Durchläufen, 5.444E-05 ms pro]
• str.Format 5.67x 6750 Ticks vergangen (0.675 ms) [in 10K Durchläufen, 6.75E-05 ms pro]