Por que não existe Char.Empty como String.Empty?

Existe uma razão para isso? Estou perguntando, porque se você precisasse usar muitos caracteres vazios, entraria na mesma situação que usaria quando usasse muitas strings vazias.

Edit: O motivo desse uso foi o seguinte:

myString.Replace ('c', '')

Portanto, remova todas as instâncias de 'c's do myString.

Não existe um char vazio. O mais próximo que você pode chegar é '\0'o caractere "nulo" Unicode. Dado que você pode incorporar isso em literais de string ou expressá-lo por conta própria com muita facilidade, por que você deseja um campo separado para ele? Da mesma forma, os argumentos " é fácil confundir ""e " "" não se aplicam '\0'.

Se você pudesse dar um exemplo de onde você gostaria de usá-lo e por que você acha que seria melhor, isso pode ajudar ...

Um char, diferente de uma string, é uma coisa discreta com um tamanho fixo. Uma string é realmente um contêiner de caracteres.

Portanto, Char.Empty realmente não faz sentido nesse contexto. Se você tem um char, ele não está vazio.

Não existe um personagem vazio. Sempre contém algo . Mesmo '\ 0' é um personagem.

Use o Char.MinValueque funciona da mesma forma que '\ 0'. Mas tenha cuidado, não é o mesmo que String.Empty.

Você pode usar caracteres anuláveis .

char? c

Se você não precisar da string inteira, poderá tirar proveito da execução atrasada:

public static class StringExtensions
{
    public static IEnumerable<char> RemoveChar(this IEnumerable<char> originalString, char removingChar)
    {
        return originalString.Where(@char => @char != removingChar);
    }
}

Você pode até combinar vários caracteres ...

string veryLongText = "abcdefghijk...";

IEnumerable<char> firstFiveCharsWithoutCsAndDs = veryLongText
            .RemoveChar('c')
            .RemoveChar('d')
            .Take(5);

... e apenas os 7 primeiros caracteres serão avaliados :)

EDIT: ou, melhor ainda:

public static class StringExtensions
{
    public static IEnumerable<char> RemoveChars(this IEnumerable<char> originalString,
        params char[] removingChars)
    {
        return originalString.Except(removingChars);
    }
}

e seu uso:

        var veryLongText = "abcdefghijk...";
        IEnumerable<char> firstFiveCharsWithoutCsAndDs = veryLongText
            .RemoveChars('c', 'd')
            .Take(5)
            .ToArray(); //to prevent multiple execution of "RemoveChars"

myString = myString.Replace('c'.ToString(), "");

OK, isso não é particularmente elegante para remover letras, pois o método .Replace tem uma sobrecarga que aceita parâmetros de string. Mas isso funciona para remover retornos de carro, alimentações de linha, guias, etc. Este exemplo remove caracteres de tabulação:

myString = myString.Replace('\t'.ToString(), "");

a mesma razão que não existe int.Empty. Os recipientes podem estar vazios. Valores escalares não podem ser. Se você quer dizer 0 (que não está vazio), use '\0'. Se você quer dizer null, use null:)

Um caractere é um tipo de valor, portanto, seu valor não pode ser nulo. (A menos que esteja embrulhado em um recipiente Anulável).

Como não pode ser nulo, in contém algum código numérico e cada código é mapeado para algum caractere.

Não é uma resposta para sua pergunta, mas para indicar um padrão, charvocê pode usar apenas

default(char)

que é o mesmo char.MinValueque, por sua vez, é o mesmo que \0. Não se deve usar isso para algo como uma string vazia.

Não responde sua primeira pergunta - mas, para o problema específico que você teve, você pode simplesmente usar strings em vez de caracteres, certo ?:

myString.Replace("c", "")

Existe uma razão para você não querer fazer isso?

Você também pode reconstruir sua sequência de caracteres por caractere, excluindo os caracteres dos quais deseja se livrar.

Aqui está um método de extensão para fazer isso:

    static public string RemoveAny(this string s, string charsToRemove)
    {
        var result = "";
        foreach (var c in s)
            if (charsToRemove.Contains(c))
                continue;
            else
                result += c;

        return result;
    }

Não é liso ou chique, mas funciona bem.

Use assim:

string newString = "My_String".RemoveAny("_"); //yields "MyString"

Se você deseja remover caracteres que atendem a uma condição específica, você pode usar o seguinte:

string s = "SoMEthInG";
s = new string(s.Where(c => char.IsUpper(c)).ToArray());

(Isso deixará apenas os caracteres maiúsculos na string.)

Em outras palavras, você pode "usar" a string como uma IEnumerable<char>, fazer alterações e depois convertê-la novamente em uma string, como mostrado acima.

Novamente, isso permite não só remover um caractere específico por causa da expressão lambda, embora você pode fazer isso, se você alterar a expressão lambda assim: c => c != 't'.

E quanto à BOM , o personagem mágico que a Microsoft adiciona ao início dos arquivos (pelo menos XML)?

se você quiser eliminar o caractere vazio na string, o seguinte funcionará, apenas converta para qualquer representação de tipo de dados desejada. obrigado,

private void button1_Click(object sender, EventArgs e)
    {

        Int32 i;

        String name;

        Int32[] array_number = new int[100];

        name = "1 3  5  17   8    9    6";

        name = name.Replace(' ', 'x');

        char[] chr = name.ToCharArray();


        for (i = 0; i < name.Length; i++)
        {
            if ((chr[i] != 'x'))
            {
                array_number[i] = Convert.ToInt32(chr[i].ToString());
                MessageBox.Show(array_number[i].ToString());
            }

        }

    }

Em termos de linguagem C #, o seguinte pode não fazer muito sentido. E essa não é uma resposta direta à pergunta. Mas seguir é o que eu fiz em um dos meus cenários de negócios

        char? myCharFromUI = Convert.ToChar(" ");
        string myStringForDatabaseInsert = myCharFromUI.ToString().Trim();
        if (String.IsNullOrEmpty(myStringForDatabaseInsert.Trim()))
        {
            Console.Write("Success");
        }

O nulle white spaceteve diferentes fluxos de negócios no meu projeto. Ao inserir no banco de dados, preciso inseri empty string-lo no banco de dados, se houver espaço em branco.

Sei que este é bastante antigo, mas recentemente encontrei um problema ao fazer várias substituições para tornar um nome de arquivo seguro. Primeiro, na string .NET mais recente. A função null é equivalente a um caractere vazio. Dito isto, o que está faltando no .Net é uma simples substituição de tudo o que substituirá qualquer caractere em uma matriz pelo caractere desejado. Por favor, sinta-se à vontade para referenciar o código abaixo (executado no LinqPad para teste).

// LinqPad .ReplaceAll and SafeFileName
void Main()
{

    ("a:B:C").Replace(":", "_").Dump();                     // can only replace 1 character for one character => a_B_C
    ("a:B:C").Replace(":", null).Dump();                    // null replaces with empty => aBC
    ("a:B*C").Replace(":", null).Replace("*",null).Dump();  // Have to chain for multiples 

    // Need a ReplaceAll, so I don't have to chain calls


    ("abc/123.txt").SafeFileName().Dump();
    ("abc/1/2/3.txt").SafeFileName().Dump();
    ("a:bc/1/2/3.txt").SafeFileName().Dump();
    ("a:bc/1/2/3.txt").SafeFileName('_').Dump();
    //("abc/123").SafeFileName(':').Dump(); // Throws exception as expected

}


static class StringExtensions
{

    public static string SafeFileName(this string value, char? replacement = null)
    {
        return value.ReplaceAll(replacement, ':','*','?','"','<','>', '|', '/', '\\');
    }

    public static string ReplaceAll(this string value, char? replacement, params char[] charsToGo){

        if(replacement.HasValue == false){
                return string.Join("", value.AsEnumerable().Where(x => charsToGo.Contains(x) == false));
        }
        else{

            if(charsToGo.Contains(replacement.Value)){
                throw new ArgumentException(string.Format("Replacement '{0}' is invalid.  ", replacement), "replacement");
            }

            return string.Join("", value.AsEnumerable().Select(x => charsToGo.Contains(x) == true ? replacement : x));
        }

    }

}

usar

myString.Replace ("c", "")

A maneira mais fácil de remover um caractere da string é cortá-lo

cl = cl.Trim(' ');

Remove todos os espaços em uma sequência