Perché non esiste Char.Empty come String.Empty?

C'è una ragione per questo? Ti chiedo perché se hai bisogno di usare molti caratteri vuoti, ti trovi nella stessa situazione che avresti quando usi un sacco di stringhe vuote.

Modifica: il motivo di questo utilizzo è stato questo:

myString.Replace ('c', '')

Quindi rimuovere tutte le istanze di 'c's da myString.

Non esiste un carattere vuoto. Il più vicino che puoi ottenere è '\0'il carattere "null" Unicode. Dato che puoi incorporarlo all'interno di letterali stringa o esprimerlo da solo molto facilmente, perché dovresti desiderare un campo separato per esso? Allo stesso modo, gli argomenti "è facile da confondere ""e " "" non si applicano '\0'.

Se potessi dare un esempio di dove vorresti usarlo e perché pensi che sarebbe meglio, ciò potrebbe aiutare ...

Un carattere, a differenza di una stringa, è una cosa discreta con una dimensione fissa. Una stringa è davvero un contenitore di caratteri.

Quindi, Char.Empty non ha davvero senso in quel contesto. Se hai un carattere, non è vuoto.

Non esiste un personaggio vuoto. Contiene sempre qualcosa . Anche '\ 0' è un personaggio.

Usa Char.MinValuequale funziona allo stesso modo di '\ 0'. Ma fai attenzione, non è lo stesso di String.Empty.

È possibile utilizzare caratteri nullable .

char? c

Se non hai bisogno dell'intera stringa, puoi sfruttare l'esecuzione ritardata:

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

Puoi anche combinare più personaggi ...

string veryLongText = "abcdefghijk...";

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

... e saranno valutati solo i primi 7 caratteri :)

EDIT: o, ancora meglio:

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

e il suo utilizzo:

        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, questo non è particolarmente elegante per la rimozione di lettere, poiché il metodo .Replace ha un sovraccarico che accetta parametri di stringa. Ma questo funziona per rimuovere ritorni a capo, avanzamenti di riga, schede, ecc. In questo esempio vengono rimossi i caratteri di tabulazione:

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

lo stesso motivo per cui non esiste un int.Empty. I contenitori possono essere vuoti. I valori scalari non possono essere. Se intendi 0 (che non è vuoto), usa '\0'. Se vuoi dire null, allora usa null:)

Un carattere è un tipo di valore, quindi il suo valore non può essere nullo. (A meno che non sia avvolto in un contenitore Nullable).

Dal momento che non può essere nullo, in contiene un codice numerico e ogni codice è associato a un carattere.

Non una risposta alla tua domanda, ma per indicare un valore predefinito charpuoi usare solo

default(char)

che è lo stesso di quello char.MinValuea sua volta \0. Non si dovrebbe usare se per qualcosa come una stringa vuota però.

Non risponde alla tua prima domanda - ma per il problema specifico che hai avuto, puoi semplicemente usare stringhe invece di caratteri, giusto ?:

myString.Replace("c", "")

C'è un motivo per cui non vorresti farlo?

Puoi anche ricostruire il carattere stringa per carattere, esclusi i caratteri di cui vuoi sbarazzarti.

Ecco un metodo di estensione per fare questo:

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

Non è lucido o elegante, ma funziona bene.

Usa così:

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

Se si desidera rimuovere caratteri che soddisfano una condizione specifica, è possibile utilizzare questo:

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

(Questo lascerà solo i caratteri maiuscoli nella stringa.)

In altre parole, è possibile "utilizzare" la stringa come una IEnumerable<char>, apportare modifiche su di essa e quindi riconvertirla in una stringa come mostrato sopra.

Ancora una volta, questo permette di rimuovere non solo una specifica char a causa della espressione lambda, anche se è possibile farlo se si cambia l'espressione lambda in questo modo: c => c != 't'.

Che ne dite di BOM , il carattere magico che Microsoft aggiunge all'inizio dei file (almeno XML)?

se si desidera eliminare il carattere vuoto nella stringa, funzionerà quanto segue, semplicemente convertire in qualsiasi rappresentazione del tipo di dati desiderata. Grazie,

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

        }

    }

In termini di linguaggio C #, ciò che segue potrebbe non avere molto senso. E questa non è una risposta diretta alla domanda. Ma i volatili sono ciò che ho fatto in uno dei miei scenari aziendali

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

L' nulle white spacedi business diverso avuto scorre nel mio progetto. Durante l'inserimento nel database, devo inserire empty stringnel database se si tratta di uno spazio bianco.

So che questo è piuttosto vecchio, ma di recente ho riscontrato un problema con la necessità di effettuare più sostituzioni per rendere sicuro un nome di file. Innanzitutto, nell'ultima stringa .NET. La funzione di sostituzione null è l'equivalente di un carattere vuoto. Detto questo, ciò che manca a .Net è una semplice sostituzione che sostituirà qualsiasi carattere in un array con il carattere desiderato. Non esitate a fare riferimento al codice seguente (funziona in LinqPad per i test).

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

    }

}

uso

myString.Replace ("c", "")

Il modo più semplice per rimuovere un carattere dalla stringa è di tagliarlo

cl = cl.Trim(' ');

Rimuove tutti gli spazi in una stringa