¿Por qué no hay Char.Empty como String.Empty?

¿Hay alguna razón para esto? Le pregunto porque si necesita usar muchos caracteres vacíos, entonces se encuentra en la misma situación que cuando usa muchas cadenas vacías.

Editar: El motivo de este uso fue este:

myString.Replace ('c', '')

Entonces, elimine todas las instancias de 'c's de myString.

No hay tal cosa como un carbón vacío. Lo más cercano que puede obtener es '\0'el carácter "nulo" de Unicode. Dado que puede incrustar eso dentro de los literales de cadena o expresarlo por sí solo muy fácilmente, ¿por qué querría un campo separado para él? Igualmente, los argumentos de " es fácil confundir ""y " "" no se aplican '\0'.

Si pudiera dar un ejemplo de dónde desea usarlo y por qué cree que sería mejor, eso podría ayudar ...

Un char, a diferencia de una cadena, es algo discreto con un tamaño fijo. Una cadena es realmente un contenedor de caracteres.

Entonces, Char.Empty realmente no tiene sentido en ese contexto. Si tienes un carbón, no está vacío.

No existe un personaje vacío. Siempre contiene algo . Incluso '\ 0' es un personaje.

Utilice el Char.MinValueque funciona igual que '\ 0'. Pero ten cuidado, no es lo mismo que String.Empty.

Podrías usar caracteres anulables .

char? c

Si no necesita la cadena completa, puede aprovechar la ejecución retrasada:

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

Incluso puedes combinar varios personajes ...

string veryLongText = "abcdefghijk...";

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

... y solo se evaluarán los primeros 7 caracteres :)

EDITAR: o, mejor aún:

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

y su 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, esto no es particularmente elegante para eliminar letras, ya que el método .Replace tiene una sobrecarga que toma parámetros de cadena. Pero esto funciona para eliminar retornos de carro, saltos de línea, pestañas, etc. Este ejemplo elimina los caracteres de tabulación:

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

la misma razón por la que no hay un int.Empty. Los contenedores pueden estar vacíos. Los valores escalares no pueden ser. Si quiere decir 0 (que no está vacío), use '\0'. Si quieres decir null, entonces usa null:)

Un carácter es un tipo de valor, por lo que su valor no puede ser nulo. (A menos que esté envuelto en un contenedor Nullable).

Como no puede ser nulo, contiene un código numérico y cada código se asigna a algún carácter.

No es una respuesta a su pregunta, pero para denotar un valor predeterminado char, puede usar solo

default(char)

que es lo mismo char.MinValueque a su vez es lo mismo que \0. Sin embargo, no se debe usar para algo como una cadena vacía.

No responde su primera pregunta, pero para el problema específico que tuvo, puede usar cadenas en lugar de caracteres, ¿verdad ?:

myString.Replace("c", "")

¿Hay alguna razón por la que no quieras hacer eso?

También puede reconstruir su cadena carácter por carácter, excluyendo los caracteres de los que desea deshacerse.

Aquí hay un método de extensión para hacer esto:

    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;
    }

No es elegante ni elegante, pero funciona bien.

Usar así:

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

Si desea eliminar caracteres que satisfacen una condición específica, puede usar esto:

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

(Esto dejará solo los caracteres en mayúscula en la cadena).

En otras palabras, puede "usar" la cadena como un IEnumerable<char> , hacer cambios en ella y luego convertirla nuevamente a una cadena como se muestra arriba.

De nuevo, esto permite no sólo eliminar un caracter específico debido a la expresión lambda, aunque puede hacerlo si cambia la expresión lambda como esto: c => c != 't'.

¿Qué tal BOM , el personaje mágico que Microsoft agrega al inicio de los archivos (al menos XML)?

si desea eliminar el carácter vacío en la cadena, lo siguiente funcionará, simplemente conviértalo a cualquier representación de tipo de datos que desee. Gracias,

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());
            }

        }

    }

En términos de lenguaje C #, lo siguiente puede no tener mucho sentido. Y esta no es una respuesta directa a la pregunta. Pero fowlloing es lo que hice en uno de mis escenarios comerciales

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

El nully white spacetenía diferentes flujos de negocios en mi proyecto. Al insertar en la base de datos, necesito insertar empty stringen la base de datos si es un espacio en blanco.

Sé que este es bastante viejo, pero recientemente encontré un problema con tener que hacer múltiples reemplazos para que un nombre de archivo sea seguro. Primero, en la última cadena .NET. La función de reemplazo nulo es el equivalente al carácter vacío. Dicho esto, lo que falta en .Net es un simple reemplazo de todo lo que reemplazará cualquier carácter en una matriz con el carácter deseado. No dude en consultar el código a continuación (se ejecuta en LinqPad para realizar pruebas).

// 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));
        }

    }

}

utilizar

myString.Replace ("c", "")

La forma más fácil de eliminar un personaje de una cadena es recortarlo

cl = cl.Trim(' ');

Elimina todos los espacios en una cadena