[C#] Perché non c'è Char.Empty come String.Empty?


Answers

La tua dichiarazione

 myString.Replace ('c', '\0')

Non rimuoverà alcun personaggio. Li sostituirà semplicemente con '\0' (End-Of-String, EOS), con conseguenze diverse. Alcune operazioni sulle stringhe potrebbero interrompersi quando si incontra una EOS, ma in .NET molte azioni la tratteranno come qualsiasi altro carattere. Meglio evitare '\0' il più possibile.

La ragione di questo utilizzo era questa: myString.Replace ('c', '') Quindi rimuovi tutte le istanze di 'c' da myString.

Per rimuovere un carattere specifico da una stringa, puoi utilizzare l'overload di stringhe:

 myString = myString.Replace ("c", String.Empty);
Question

C'è una ragione per questo? Ti sto chiedendo perché se avessi bisogno di usare molti caratteri vuoti, ti ritroverai nella stessa situazione che avresti quando userai un sacco di stringhe vuote.

Modifica: il motivo di questo utilizzo era questo:

myString.Replace ('c', '')

Quindi rimuovi tutte le istanze di "c" da myString.




So che questo è piuttosto vecchio, ma recentemente ho riscontrato un problema con dover fare più sostituzioni per rendere sicuro un nome di file. Innanzitutto, nell'ultima stringa .NET. La funzione null è l'equivalente del carattere vuoto. Detto questo, ciò che manca a .Net è una semplice sostituzione di tutto ciò che sostituirà qualsiasi carattere in un array con il carattere desiderato. Non esitate a fare riferimento al codice sottostante (eseguito in LinqPad per il 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));
        }

    }

}



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

myString.Replace("c", "")

C'è una ragione per cui non vorresti farlo?




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




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

cl = cl.Trim(' ');

Rimuove tutti gli spazi in una stringa




Potresti usare caratteri nullable .

char? c



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 intendi null , quindi usa null :)




se si desidera eliminare il carattere vuoto nella stringa, il seguente funzionamento funzionerà, basta convertire in qualsiasi rappresentazione di 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());
            }

        }

    }



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

OK, questo non è particolarmente elegante per la rimozione di lettere, dal momento che il metodo .Replace ha un sovraccarico che richiede parametri di stringa. Ma questo funziona per rimuovere ritorni a capo, avanzamenti di riga, schede, ecc. Questo esempio rimuove i caratteri di tabulazione:

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



Se vuoi rimuovere caratteri che soddisfano una condizione specifica, puoi usare questo:

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

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

In altre parole, è possibile convertire la stringa in IEnumerable<char> , apportare modifiche e quindi riconvertirla in una stringa come mostrato sopra.

Di nuovo, questo consente non solo di rimuovere un char specifico a causa dell'espressione lambda, sebbene sia possibile farlo se si modifica l'espressione lambda in questo modo: c => c != 't' .