Em C #, devo usar string.Empty ou String.Empty ou “” para inicializar uma string?

Em C #, quero inicializar um valor de sequência com uma sequência vazia.

Como devo fazer isso? Qual é o caminho certo e por quê?

string willi = string.Empty;

ou

string willi = String.Empty;

ou

string willi = "";

ou o que?

Use o que você e sua equipe acharem mais legíveis.

Outras respostas sugeriram que uma nova string seja criada toda vez que você usar "". Isso não é verdade - devido à internação de strings, ele será criado uma vez por assembly ou uma vez por AppDomain (ou possivelmente uma vez para todo o processo - não tenho certeza dessa parte da frente). Essa diferença é insignificante - massivamente, massivamente insignificante.

Porém, o que você acha mais legível é uma questão diferente. É subjetivo e varia de pessoa para pessoa. Por isso, sugiro que você descubra como a maioria das pessoas da sua equipe gosta e que tudo isso seja consistente. Pessoalmente, acho ""mais fácil ler.

O argumento de que ""e " "é facilmente confundido com o outro realmente não lavar comigo. A menos que você esteja usando uma fonte proporcional (e eu não trabalhei com nenhum desenvolvedor que o faça), é muito fácil perceber a diferença.

Realmente não há diferença do ponto de vista de desempenho e código gerado. Nos testes de desempenho, eles iam e voltavam entre os quais era mais rápido do que o outro e apenas em milissegundos.

Ao olhar para o código dos bastidores, você também não vê nenhuma diferença. A única diferença está no IL, que string.Emptyusa o opcode ldsfld e ""o opcode ldstr, mas isso é apenas porque string.Emptyé estático, e as duas instruções fazem a mesma coisa. Se você observar a montagem produzida, é exatamente a mesma.

Código C #

private void Test1()
{
    string test1 = string.Empty;    
    string test11 = test1;
}

private void Test2()
{
    string test2 = "";    
    string test22 = test2;
}

Código IL

.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

Código de montagem

        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 

O melhor código é nenhum código :

A natureza fundamental da codificação é que nossa tarefa, como programadores, é reconhecer que toda decisão que tomamos é uma troca. […] Comece com brevidade. Aumente as outras dimensões conforme exigido pelo teste.

Consequentemente, menos código é melhor código: Prefere ""ao string.Emptyou String.Empty. Essas duas são seis vezes mais sem benefícios adicionais - certamente sem clareza adicional, pois expressam exatamente as mesmas informações.

Uma diferença é que, se você usa uma switch-casesintaxe, não pode escrever case string.Empty:porque não é uma constante. Você recebe umCompilation error : A constant value is expected

Veja este link para obter mais informações: string-empty-versus-empty-quotes

Eu prefiro stringa String. escolher string.Emptysobre ""é uma questão de escolher um e ficar com ele. A vantagem de usar string.Emptyé que é muito óbvio o que você quer dizer, e você não copia acidentalmente caracteres não imprimíveis como "\x003"no seu "".

Eu não iria gritar, mas estou vendo algumas informações erradas sendo jogadas aqui.

Eu, pessoalmente, prefiro string.Empty. Essa é uma preferência pessoal, e eu me inclino à vontade de qualquer equipe com quem eu trabalhe, caso a caso.

Como alguns outros mencionaram, não há diferença entre string.Emptye String.Empty.

Além disso, e esse é um fato pouco conhecido, usar "" é perfeitamente aceitável. Todas as instâncias de "" criarão um objeto em outros ambientes. No entanto, o .NET armazena suas seqüências de caracteres, portanto, as instâncias futuras extrairão a mesma sequência imutável do pool de estagiários e qualquer ocorrência de desempenho será insignificante. Fonte: Brad Abrams .

Eu pessoalmente prefiro "" a menos que haja uma boa razão para algo mais complexo.

String.Emptye string.Emptysão equivalentes. Stringé o nome da classe BCL; stringé o alias do C # (ou atalho, se você desejar). O mesmo que com Int32e int. Veja os documentos para mais exemplos.

No que diz ""respeito, não tenho muita certeza.

Pessoalmente, eu sempre uso string.Empty.

Quase todos os desenvolvedores sabem o que significa "". Eu pessoalmente encontrei o String.Empty pela primeira vez e tive que gastar algum tempo pesquisando no google para descobrir se eles realmente são exatamente a mesma coisa.

Esse tópico é bastante antigo e longo, com licença, se esse comportamento tiver sido mencionado em outro lugar. (E me aponte para a resposta que cobre isso)

Eu encontrei uma diferença no comportamento do compilador se você usar string.Emptyou aspas duplas. A diferença é exibida se você não usar a variável string inicializada com string.Empty ou com aspas duplas.

Em caso de inicialização com string.Emptyo Aviso do Compilador

CS0219 - The variable 'x' is assigned but its value is never used

nunca é emitido enquanto, no caso de inicialização com aspas duplas, você obtém a mensagem esperada.

Esse comportamento é explicado no artigo Conectar neste link: https://connect.microsoft.com/VisualStudio/feedback/details/799810/c-warning-cs0219-not-reported-when-assign-non-constant-value

Basicamente, se eu entendi direito, eles querem permitir que um programador defina uma variável com o valor de retorno de uma função para fins de depuração sem incomodá-lo com uma mensagem de aviso, limitando o aviso apenas no caso de atribuições e seqüências de caracteres dispendiosas. Vazio não é uma constante, mas um campo.

Eu executei esse teste muito simples usando o seguinte método em um aplicativo de console:

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
}

Isso sugere claramente que as três variáveis str1, a saber , str2e str3embora sejam inicializadas usando sintaxe diferente, estão apontando para o mesmo objeto de string (de comprimento zero) na memória. Eu executei este teste no aplicativo de console .NET 4.5. Portanto, internamente, eles não têm diferença e tudo se resume à conveniência de qual você deseja usar como programador. Esse comportamento da classe de string é conhecido como interning de string no .NET. Eric Lippert tem um blog muito bom aqui descrevendo esse conceito.

Qualquer uma das anteriores.

Há muitas, muitas coisas melhores para pontificar. Como a cor da casca que melhor se adapta a uma árvore, acho que marrom vago com reflexos de musgo doce.

Eu prefiro o String.Empty, além dos outros motivos para garantir que você saiba o que é e que não removeu acidentalmente o conteúdo, mas principalmente para a internacionalização. Se eu vejo uma string entre aspas, sempre tenho que me perguntar se esse código é novo e deve ser colocado em uma tabela de strings. Então, toda vez que o código é alterado / revisado, você precisa procurar "algo entre aspas" e sim, pode filtrar as cadeias vazias, mas digo às pessoas que é uma boa prática nunca colocar cadeias entre aspas, a menos que você saiba que não será localizado .

Ninguém mencionou que no VisualStudio String o código de cores é diferente do que o string. O que é importante para facilitar a leitura. Além disso, letras minúsculas geralmente são usadas para vars e tipo, não um grande problema, mas String.Empty é uma constante e não uma var ou tipo.

stringé sinônimo de System.Stringtipo, eles são idênticos.

Os valores também são idênticos: string.Empty == String.Empty == ""

Eu não usaria constantes de caracteres "" no código, string.Emptyou String.Empty- mais fácil ver o que significava programador.

Entre stringe Stringeu gosto mais de letras minúsculas, stringsó porque eu costumava trabalhar com Delphi por muitos anos e o estilo Delphi é minúsculo string.

Então, se eu fosse seu chefe, você estaria escrevendo string.Empty

Eu seria a favor de string.Emptymais String.Emptyporque você pode usá-lo sem a necessidade de incluir um using System;no seu arquivo.

Como para a colheita ""mais string.Empty, é preferência pessoal e deve ser decidida por sua equipe.

Eu não faço diferença. O último é o mais rápido de digitar :)

Não importa - eles são exatamente a mesma coisa. No entanto, o principal é que você deve ser consistente

ps Luto com esse tipo de "qual é a coisa certa" o tempo todo.

É totalmente uma preferência de estilo de código, como o .NET lida com seqüências de caracteres. No entanto, aqui estão as minhas opiniões :)

Eu sempre uso os nomes de tipo BCL ao acessar métodos, propriedades e campos estáticos: String.EmptyouInt32.TryParse(...) ouDouble.Epsilon

Eu sempre uso as palavras-chave C # ao declarar novas instâncias: int i = 0; oustring foo = "bar";

Eu raramente uso literais de cadeia não declarada, pois gosto de poder escanear o código para combiná-lo em constantes nomeadas reutilizáveis. O compilador substitui as constantes pelos literais de qualquer maneira, portanto é mais uma maneira de evitar números / seqüências mágicas e dar um pouco mais de significado a elas com um nome. Além disso, alterar os valores é mais fácil.

Eu uso o terceiro, mas dos outros dois o primeiro parece menos estranho. string é um alias para String, mas vê-los em uma atribuição parece errado.

Qualquer um dos dois primeiros seria aceitável para mim. Eu evitaria o último, porque é relativamente fácil introduzir um erro, colocando um espaço entre as aspas. Este bug em particular seria difícil de encontrar por observação. Supondo que não haja erros de digitação, todos são semanticamente equivalentes.

[EDITAR]

Além disso, você pode sempre usar uma stringou outra Stringconsistência, mas sou apenas eu.

Eu testemunhei pessoalmente "" resultando em problemas (menores) duas vezes. Uma vez foi devido a um erro de um desenvolvedor júnior novo na programação baseada em equipes, e o outro foi um erro de digitação simples, mas o fato é o uso de string.Empty teria evitado os dois problemas.

Sim, essa é uma decisão de julgamento, mas quando um idioma oferece várias maneiras de fazer as coisas, eu tendem a me inclinar para aquele que tem a supervisão mais compiladora e a execução mais forte em tempo de compilação. Isso não é "". É tudo uma questão de expressar intenção específica.

Se você digitar string.EMpty ou Strng.Empty, o compilador informa que você fez isso errado. Imediatamente. Simplesmente não será compilado. Como desenvolvedor, você está citando assuntos específicos. intenção que o compilador (ou outro desenvolvedor) não possa interpretar mal de forma alguma e, quando você faz isso errado, não pode criar um bug.

Se você digitar "" quando quiser "" ou vice-versa, o compilador fará o que você pediu. Outro desenvolvedor pode ou não conseguir coletar sua intenção específica. Bug criado.

Muito antes da string.Empty, usei uma biblioteca padrão que definia a constante EMPTY_STRING. Ainda usamos essa constante nas instruções de caso em que string.Empty não é permitido.

Sempre que possível, coloque o compilador para trabalhar para você e elimine a possibilidade de erro humano, por menor que seja. Na IMO, isso supera a "legibilidade", como outros já citaram.

Especificidade e tempo de compilação. É o que tem para o jantar.

Eu uso "" porque será colorido em amarelo no meu código ... por algum motivo, String.Empty é todo branco no meu tema do Visual Studio Code. E acredito que isso é o mais importante para mim.

O compilador deve torná-los iguais a longo prazo. Escolha um padrão para que seu código seja fácil de ler e fique com ele.

Eu estava apenas olhando para algum código e essa pergunta surgiu em minha mente, que eu já havia lido algum tempo antes. Esta é certamente uma questão de legibilidade.

Considere o seguinte código C # ...

(customer == null) ? "" : customer.Name

vs

(customer == null) ? string.empty : customer.Name

Pessoalmente, acho o último menos ambíguo e mais fácil de ler.

Como apontado por outros, as diferenças reais são insignificantes.

Acho que o segundo é "adequado", mas para ser sincero, não acho que isso importe. O compilador deve ser inteligente o suficiente para compilar qualquer um deles exatamente no mesmo bytecode. Eu uso "" eu mesmo.

Embora a diferença seja muito, MUITO pequena, a diferença ainda existe.

1) "" cria um objeto enquanto String.Empty não. Mas este objeto será criado uma vez e será referenciado a partir do conjunto de cadeias posteriormente, se você tiver outro "" no código.

2) String e string são as mesmas, mas eu recomendaria usar String.Empty (assim como String.Format, String.Copy etc.), pois a notação de ponto indica classe, não operador, e a classe que começa com letra maiúscula está em conformidade com Padrões de codificação em C #.

Em http://blogs.msdn.com/b/brada/archive/2003/04/22/49997.aspx :

Como David implica, há diferenças entre String.Emptye ""são bem pequenas, mas há uma diferença. ""na verdade, cria um objeto, provavelmente será retirado do pool interno de strings, mas ainda assim ... enquanto String.Emptynão cria nenhum objeto ... por isso, se você realmente estiver procurando por eficiência de memória, sugiro String.Empty. No entanto, você deve ter em mente que a diferença é tão rival que você nunca gostará de vê-la no seu código ...
Quanto a System.String.Emptyou string.Emptyou String.Empty... meu nível de atenção é baixo ;-)

A cadeia vazia é como um conjunto vazio, apenas um nome que todo mundo usa para chamar "". Também em linguagens formais, as strings criadas a partir de um alfabeto com comprimento zero são chamadas de strings vazias. O conjunto e a sequência possuem um símbolo especial. Cadeia vazia: ε e conjunto vazio: ∅. Se você quiser falar sobre essa string de comprimento zero, você a chamará de string vazia, para que todos saibam exatamente a que você está se referindo. Agora, caso você o nomeie como uma string vazia, por que não usar string.Emptyno código, isso mostra que a intenção é explícita. A desvantagem é que não é uma constante e, portanto, não está disponível em todos os lugares, como nos atributos. (Não é uma constante por alguns motivos técnicos, consulte a fonte de referência.)

Eu prefiro ""porque é mais curto e String.Emptyresolve um problema que não existe.