Fa .NET hanno un modo di risolvere una stringa nulla per String.Empty?

StackOverflow https://stackoverflow.com/questions/1241112

  •  12-09-2019
  •  | 
  •  

Domanda

Ho un metodo di una linea che risolve una stringa nulla per string.Empty che ho pensato che potrebbe essere utile come un metodo di estensione -. Ma non riesco a trovare un modo utile per fare in modo

L'unico modo ho potuto vedere, essendo utile è un metodo statico della classe stringa perché ovviamente non può essere attribuito a un'istanza come istanza è nullo e ciò causa un errore di compilazione. [Edit: errore di compilazione è dovuto alla variabile non inizializzata, che ho interpretato male]

ho pensato di aggiungere a una classe di supporto, ma che aggiunge solo inutili complessità dal punto di vista reperibilità.

Quindi questa domanda è in due parti suppongo:

  1. Fa il framework .NET ha un costruito in modo di risolvere una stringa null per string.Empty che è risaputo che ho perso da qualche parte lungo la strada?
  2. Se non lo fa - qualcuno sa di un modo per aggiungere questo metodo come estensione statico della classe string
    3. ?

Saluti di anticipo

Modifica:

Va bene, penso che avrei dovuto essere un po 'più chiara - Sono già ben consapevole di coallescing nulla e stavo usando questo in un posto dove ho una dozzina di stringhe da ispezionare per il calcolo di un codice hash.

Come si può immaginare, 12 righe di codice da vicino si susseguono tutti contenenti la sintassi coallescing null è un pugno nell'occhio, così ho spostato l'operazione coallescing nulla fuori ad un metodo per rendere le cose più facili facile per gli occhi. Che è perfetto, però, sarebbe una perfetta estensione all'oggetto stringa: 

int hashcode =
FirstValue.ResolveNull().GetHashCode() ^
SecondValue.ResolveNull().GetHashCode() ^
...

oltre una dozzina di linee è molto più facile da leggere rispetto: 

int hashcode =
(FirstValue ?? String.Empty).GetHashCode() ^
(SecondValue ?? String.Empty).GetHashCode() ^
...

stavo correndo in problemi del compilatore quando non ha dichiarato esplicitamente i miei valori di stringa come nulla, ma si è basata sulle implicita: 

 string s;

Se, tuttavia, è esplicitamente definito: 

string s = null;

Si può facilmente chiamare: 

s.ResolveNull();

Grazie a tutti per il vostro contributo.

È stato utile?

Soluzione

  

L'unico modo ho potuto vedere, essendo utile è un metodo statico della classe stringa perché ovviamente non può essere attribuito a un'istanza come istanza è nullo e ciò causerebbe un errore di esecuzione.

C # 3.0 metodi di estensione possono essere chiamati su ricevitori nulli (dal momento che sono statiche, in pratica), ma si comportano come metodi di istanza. Quindi, solo renderlo un metodo di estensione.

Altri suggerimenti

Non credo che ci sia qualcosa di costruito per questo. Il mio primo pensiero, e quello che faccio spesso, è usare l'operatore si fondono: 

string s = null;
string x = s ?? string.Empty;

someExpressionInvolving (s ?? "");

Non v'è alcun punto sempre entusiasti string.Empty vs "" - non v'è differenza trascurabile: 

Console.WriteLine(ReferenceEquals(string.Empty, "")); // true

metodo di estensione: 

public static class StringExtensions
{
    public static String EmptyIfNull(this String instance)
    {
        return instance ?? String.Empty;
    }
}

Naturalmente, si può altrettanto facilmente scrivere instance ?? String.Empty in luoghi in cui è necessario utilizzare String.Empty invece di null. 

string test = CouldReturnNull() ?? string.Empty;

È possibile utilizzare il ?? Operator (operatore null coalescenza) in C # - è questo che vuoi dire? Oppure ho capito male?

ad es. 

string n = null;
string y = n ?? String.Empty;

y = farebbe String.Empty; 

string abc = s ?? string.Empty;

Direi che l'attuazione di questo come un metodo di estensione si sentirebbe un po 'come quello che abbiamo in Svezia chiamata "di viaggiare verso l'altro lato del torrente a prendere l'acqua" . Quando ho bisogno di assicurare ottengo una stringa vuota invece di null ho spesso appena concateno con string.Empty: 

public void SomeMethod(string param)
{
    string notNull = param + string.Empty;
}

Certo, questo può portare a un'istanza corda in più in fase di creazione, ma nella maggior parte delle situazioni del mondo reale sono stato in questo non è stato un problema.

Non c'è costruire in funzione per questo. Ma si può scrivere un metodo di piccola estensione (o un menthod statico) per il tipo di stringa con una dichiarazione come:

di ritorno s ?? string.Emtpy;

Basta aggiungere string.Empty per qualsiasi stringa variabile e questo ti garantirà di non ottenere mai nulla 

string a = null;
string b = null + string.Empty;
string c = "a" + string.Empty;

(a == string.Empty).Dump(); // False
(b == string.Empty).Dump(); // True
(c == "a").Dump(); // True

ho buttato questo LINQPad, quindi la .dump () s '

Guardando le opzioni ...

Questa tecnica 

string b = null + string.Empty;

genera 

IL_0001:  ldsfld      System.String.Empty
IL_0006:  dup         
IL_0007:  brtrue.s    IL_000F
IL_0009:  pop         
IL_000A:  ldstr       ""
IL_000F:  stloc.0

L'altra opzione popolare: 

string b = null ?? string.empty

genera 

IL_0001:  ldsfld      System.String.Empty
IL_0006:  stloc.0

e questo 

string b = null + "";

genera questo 

IL_0001:  ldstr       ""
IL_0006:  stloc.0

ho ancora favorevole 

string b = null + "";

Ma in realtà, IMO, si dovrebbe solo essere pronti a gestire null quando si digerire la stringa

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top