Por que o valor padrão do tipo de sequência é nulo em vez de uma sequência vazia?

É muito chato testar todas as minhas strings nullantes que eu possa aplicar com segurança métodos como ToUpper(), StartWith()etc ...

Se o valor padrão de stringfosse a sequência vazia, eu não precisaria testar e sentiria que era mais consistente com os outros tipos de valor, como intou doublepor exemplo. Além disso Nullable<String>, faria sentido.

Então, por que os designers de C # optaram por usar nullcomo o valor padrão de strings?

Nota: Isso está relacionado a esta questão , mas é mais focado no porquê, em vez do que fazer com ele.

Por que o valor padrão do tipo de sequência é nulo em vez de uma sequência vazia?

Porque stringé um tipo de referência e o valor padrão para todos os tipos de referência é null.

É muito irritante testar todas as minhas strings como null antes que eu possa aplicar com segurança métodos como ToUpper (), StartWith () etc ...

Isso é consistente com o comportamento dos tipos de referência. Antes de chamar os membros da instância, deve-se colocar uma verificação para uma referência nula.

Se o valor padrão de string fosse vazio, eu não precisaria testar e sentiria que era mais consistente com os outros tipos de valores, como int ou double, por exemplo.

Atribuir o valor padrão a um tipo de referência específico que nullnão o tornaria inconsistente .

Além disso Nullable<String>, faria sentido.

Nullable<T>trabalha com os tipos de valor. É digno de nota o fato de que Nullablenão foi introduzido na plataforma .NET original; portanto, haveria muito código quebrado se eles alterassem essa regra. ( Cortesia: @jcolebrand )

Habib está certo - porque stringé um tipo de referência.

Mais importante, porém, você não precisa verificar nullcada vez que o usa. Você provavelmente deve jogar a ArgumentNullExceptionse alguém passar uma nullreferência à sua função .

Aqui está a coisa - a estrutura lançaria um NullReferenceExceptionpara você de qualquer maneira, se você tentasse chamar .ToUpper()uma string. Lembre-se de que esse caso ainda pode ocorrer mesmo se você testar seus argumentos, nullpois qualquer propriedade ou método nos objetos passados ​​para sua função como parâmetros podem ser avaliados null.

Dito isto, verificar se há cadeias vazias ou nulos é uma coisa comum a ser feita, portanto eles fornecem String.IsNullOrEmpty()e String.IsNullOrWhiteSpace()exatamente para esse fim.

Você pode escrever um método de extensão (pelo que vale a pena):

public static string EmptyNull(this string str)
{
    return str ?? "";
}

Agora isso funciona com segurança:

string str = null;
string upper = str.EmptyNull().ToUpper();

Você também pode usar o seguinte, a partir do C # 6.0

string myString = null;
string result = myString?.ToUpper();

O resultado da sequência será nulo.

Seqüências de caracteres vazias e nulos são fundamentalmente diferentes. Um nulo é a ausência de um valor e uma sequência vazia é um valor vazio.

A linguagem de programação que faz suposições sobre o "valor" de uma variável, nesse caso, uma sequência vazia, será tão boa quanto iniciar a sequência com qualquer outro valor que não cause um problema de referência nulo.

Além disso, se você passar o identificador para essa variável de cadeia de caracteres para outras partes do aplicativo, esse código não terá como validar se você passou intencionalmente um valor em branco ou se esqueceu de preencher o valor dessa variável.

Outra ocasião em que isso seria um problema é quando a string é um valor de retorno de alguma função. Como string é um tipo de referência e tecnicamente pode ter um valor nulo e vazio, ambos, portanto, a função também pode retornar tecnicamente nulo ou vazio (não há nada para impedir isso). Agora, como existem 2 noções de "ausência de valor", ou seja, uma string vazia e uma nula, todo o código que consome esta função terá que fazer 2 verificações. Um para vazio e outro para nulo.

Em resumo, é sempre bom ter apenas 1 representação para um único estado. Para uma discussão mais ampla sobre vazios e nulos, consulte os links abaixo.

/software/32578/sql-empty-string-vs-null-value

NULL vs Vazio ao lidar com a entrada do usuário

A razão / problema fundamental é que os projetistas da especificação CLS (que definem como as linguagens interagem com .net) não definiram um meio pelo qual os membros da classe pudessem especificar que deveriam ser chamados diretamente, e não via callvirt, sem que o chamador realizasse uma chamada. verificação de referência nula; nem forneceu um meio de definir estruturas que não estariam sujeitas ao boxe "normal".

Se a especificação CLS definisse esses meios, seria possível que o .net seguisse consistentemente o lead estabelecido pelo Common Object Model (COM), sob o qual uma referência de cadeia nula fosse considerada semanticamente equivalente a uma cadeia vazia e por outras tipos de classe imutáveis ​​definidos pelo usuário que deveriam ter semântica de valores para definir da mesma forma os valores padrão. Essencialmente, o que aconteceria seria para cada membro String, por exemplo, Lengthser escrito como algo parecido [InvokableOnNull()] int String Length { get { if (this==null) return 0; else return _Length;} }. Essa abordagem ofereceria semântica muito boa para coisas que deveriam se comportar como valores, mas, devido a problemas de implementação, precisam ser armazenados no heap. A maior dificuldade com essa abordagem é que a semântica da conversão entre esses tipos e Objectpode ficar um pouco obscura.

Uma abordagem alternativa seria permitir a definição de tipos de estrutura especiais que não foram herdados, Objectmas que tinham operações personalizadas de boxe e unboxing (que seriam convertidas para / de outro tipo de classe). Sob essa abordagem, haveria um tipo de classe NullableStringque se comporta como a string agora e um tipo de estrutura personalizada String, que conteria um único campo particular Valuedo tipo String. A tentativa de converter um Stringpara NullableStringou Objectretornaria Valuese não for nulo ou String.Emptyse for nulo. Tentando converter para String, uma referência não nula a uma NullableStringinstância armazenaria a referência Value(talvez armazenando nulo se o comprimento fosse zero); lançar qualquer outra referência lançaria uma exceção.

Mesmo que as strings precisem ser armazenadas no heap, conceitualmente não há razão para que elas não devam se comportar como tipos de valor que possuem um valor padrão não nulo. Tê-los armazenados como uma estrutura "normal", que continha uma referência, seria eficiente para o código que os utilizava como tipo "string", mas teria adicionado uma camada extra de indireção e ineficiência ao converter para "objeto". Embora eu não preveja o .net adicionando um dos recursos acima até essa data tardia, talvez designers de estruturas futuras possam considerar a possibilidade de incluí-los.

Como uma variável de cadeia é uma referência , não uma instância .

Inicializá-lo como Empty por padrão seria possível, mas introduziria muitas inconsistências em todo o quadro.

Por que os designers de C # optaram por usar null como o valor padrão de strings?

Como cadeias de caracteres são tipos de referência , os tipos de referência são o valor padrão null. Variáveis ​​de tipos de referência armazenam referências aos dados reais.

Vamos usar a defaultpalavra-chave para este caso;

string str = default(string); 

stré um string, então é um tipo de referência , então o valor padrão é null.

int str = (default)(int);

stré um int, então é um tipo de valor , então o valor padrão é zero.

Se o valor padrão de stringfosse a string vazia, eu não precisaria testar

Errado! Alterar o valor padrão não altera o fato de ser um tipo de referência e alguém ainda pode definir explicitamente a referência como sendo null.

Além disso Nullable<String>, faria sentido.

Verdadeiro ponto. Seria mais sensato não permitir nullnenhum tipo de referência, mas exigir Nullable<TheRefType>esse recurso.

Então, por que os designers de C # optaram por usar nullcomo o valor padrão de strings?

Consistência com outros tipos de referência. Agora, por que permitir nulltipos de referência? Provavelmente para parecer C, mesmo que essa seja uma decisão de design questionável em um idioma que também fornece Nullable.

Talvez se você usaria ??operador ao atribuir a variável de corda, que poderia ajudá-lo.

string str = SomeMethodThatReturnsaString() ?? "";
// if SomeMethodThatReturnsaString() returns a null value, "" is assigned to str.

Uma String é um objeto imutável, o que significa que, quando determinado valor, o valor antigo não é apagado da memória, mas permanece no local antigo e o novo valor é colocado em um novo local. Portanto, se o valor padrão de String aera String.Empty, ele desperdiçaria o String.Emptybloco na memória quando receber seu primeiro valor.

Embora pareça minúsculo, pode se transformar em um problema ao inicializar uma grande variedade de cadeias com valores padrão de String.Empty. Claro, você sempre pode usar a StringBuilderclasse mutável se isso for um problema.

Como string é um tipo de referência e o valor padrão para o tipo de referência é nulo.

Talvez a stringpalavra - chave tenha confundido você, pois se parece exatamente com qualquer outra declaração de tipo de valor , mas na verdade é um alias, System.Stringconforme explicado nesta pergunta .
Além disso, a cor azul escura no Visual Studio e a primeira letra minúscula podem levar a pensar que é a struct.

Tipos anuláveis ​​não chegaram até a versão 2.0.

Se tipos anuláveis ​​tivessem sido criados no início do idioma, a string seria não anulável e a string? teria sido anulável. Mas eles não podiam fazer isso com compatibilidade com versões anteriores.

Muitas pessoas falam sobre ref-type ou não ref type, mas string é uma classe fora do comum e soluções teriam sido encontradas para tornar isso possível.