Does .NET tem uma maneira de resolver uma cadeia nula para String.Empty?

Question

Eu tenho um método de uma linha que resolve uma cadeia nula para string.Empty que achei que possa ser útil como um método de extensão -. Mas não consigo encontrar uma maneira útil de torná-lo tão

A única maneira que eu poderia vê-lo sendo útil é como um método estático na classe string porque, obviamente, não pode ser atribuído a uma instância como a instância é nula e isso faz com que um erro do compilador. [Edit: erro Compiler foi devido a variável não inicializada, que eu mal interpretado]

Eu pensei sobre adicionando-à uma classe auxiliar mas que acrescenta complexidade desnecessária do ponto de vista de descoberta.

Portanto, esta questão é em duas partes Suponho:

1. Será que o .NET framework tem um construído em forma de resolver uma cadeia nula para string.Empty que é do conhecimento comum que eu tenha perdido em algum lugar ao longo do caminho?
2. Se isso não acontecer -? Alguém sabe de uma maneira de adicionar esse método como uma extensão do estática da classe string

Cheers antecipadamente

Editar:

Ok, eu acho que deveria ter sido um pouco mais clara - eu já estou bem ciente coallescing nula e eu estava usando isso em um lugar onde eu tenho uma dúzia de cordas sendo inspecionado para o cálculo de um hash de código.

Como você pode imaginar, 12 linhas de código a seguir de perto uns aos outros tudo o que contém o nulo coallescing sintaxe é uma monstruosidade, então me mudei o nulo coallescing operação para um método para facilitar as coisas mais fáceis para os olhos. O que é perfeito, no entanto, seria uma extensão perfeito para o objeto string:

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

mais de uma dúzia de linhas é muito mais fácil de ler do que:

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

Eu estava correndo em problemas do compilador quando eu não declarar explicitamente os meus valores string como nulo, mas contou com o implícito:

 string s;

Se, no entanto, você define explicitamente:

string s = null;

Você pode facilmente ligar para:

s.ResolveNull();

Obrigado a todos por sua entrada.

Answer 1

A única maneira que eu poderia vê-lo sendo útil é como um método estático na classe string porque, obviamente, não pode ser atribuído a uma instância como a instância é nula e isso causaria um erro de execução.

métodos

C # 3.0 métodos de extensão podem ser chamados receptores nulos (uma vez que eles são estáticos na prática), mas comportam-se como instância. Assim, apenas torná-lo um método de extensão.

Answer 2

Eu não acho que haja algo construído em para isso. Meu primeiro pensamento, eo que eu faço muitas vezes, é usar o operador coalesce:

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

Answer 3

someExpressionInvolving (s ?? "");

Não há nenhum ponto ficando animado sobre string.Empty vs "" - não há diferença insignificante:

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

Answer 4

método de extensão:

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

é claro, você pode instance ?? String.Empty com a mesma facilidade de gravação em lugares onde você precisa usar String.Empty em vez de null.

Answer 5

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

Answer 6

Você pode usar o ?? Operator (operador coalescentes nulo) em C # - é isso que quer dizer? Ou ter eu entendi mal?

por exemplo.

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

y faria = String.Empty;

Answer 7

string abc = s ?? string.Empty;

Answer 8

Eu diria que implementar isso como um método de extensão iria sentir um pouco como o que na Suécia chamada "viajar para o outro lado do riacho para ir buscar água" . Quando eu preciso para garantir que eu obter uma cadeia vazia em vez de null eu muitas vezes apenas concatenar com string.Empty:

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

Claro, isso pode levar a uma instância corda extra que está sendo criado, mas na maioria das situações do mundo real, estive em este não foi um problema.

Answer 9

Não há nenhuma construção em função para isso. Mas você pode escrever um método pouco de extensão (ou um menthod estática) para o tipo string com uma declaração como:

retorno s ?? string.Emtpy;

Answer 10

Basta adicionar string.Empty a qualquer cadeia variável e você estará garantido para nunca ficar nula

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

Lancei esta em LinqPad, daí a .dump () 's

Olhando para as opções ...

Esta técnica

string b = null + string.Empty;

gera

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     

A outra opção popular:

string b = null ?? string.empty

gera

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

e este

string b = null + "";

gera este

IL_0001:  ldstr       ""
IL_0006:  stloc.0     

Eu ainda favorecem

string b = null + "";

Mas, realmente, IMO, você deve apenas estar preparado para nula pega quando você digerir a cadeia