Warum gibt es kein Char.Empty wie String.Empty?

Gibt es einen Grund dafür? Ich frage, denn wenn Sie viele leere Zeichen verwenden müssen, geraten Sie in die gleiche Situation wie wenn Sie viele leere Zeichenfolgen verwenden würden.

Bearbeiten: Der Grund für diese Verwendung war folgender:

myString.Replace ('c', '')

Entfernen Sie also alle Instanzen von 'c' aus myString.

Es gibt keinen leeren Saibling. Das nächstgelegene '\0'Zeichen ist das Unicode-Zeichen "null". Warum sollten Sie ein separates Feld dafür benötigen, da Sie dies in Zeichenfolgenliterale einbetten oder ganz einfach selbst ausdrücken können? Ebenso gelten die Argumente "Es ist leicht zu verwirren ""und " "" nicht '\0'.

Wenn Sie ein Beispiel geben könnten, wo Sie es verwenden möchten und warum Sie denken, dass es besser wäre, könnte das helfen ...

Ein Zeichen ist im Gegensatz zu einer Zeichenfolge eine diskrete Sache mit einer festen Größe. Eine Zeichenfolge ist wirklich ein Container mit Zeichen.

Char.Empty macht in diesem Zusammenhang also keinen Sinn. Wenn Sie ein Zeichen haben, ist es nicht leer.

Es gibt keinen leeren Charakter. Es enthält immer etwas . Sogar '\ 0' ist ein Zeichen.

Verwenden Sie, Char.MinValuewas genauso funktioniert wie '\ 0'. Aber sei vorsichtig, es ist nicht dasselbe wie String.Empty.

Sie könnten nullbare Zeichen verwenden.

char? c

Wenn Sie nicht die gesamte Zeichenfolge benötigen, können Sie die verzögerte Ausführung nutzen:

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

Sie können sogar mehrere Zeichen kombinieren ...

string veryLongText = "abcdefghijk...";

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

... und nur die ersten 7 Zeichen werden ausgewertet :)

EDIT: oder noch besser:

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

und seine Verwendung:

        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, dies ist nicht besonders elegant zum Entfernen von Buchstaben, da die .Replace-Methode eine Überladung aufweist, die Zeichenfolgenparameter akzeptiert. Dies funktioniert jedoch zum Entfernen von Wagenrückläufen, Zeilenvorschüben, Tabulatoren usw. In diesem Beispiel werden Tabulatorzeichen entfernt:

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

Aus dem gleichen Grund gibt es keine int.Empty. Container können leer sein. Skalarwerte können nicht sein. Wenn Sie 0 meinen (was nicht leer ist), dann verwenden Sie '\0'. Wenn du meinst null, dann benutze null:)

Ein Zeichen ist ein Werttyp, daher kann sein Wert nicht null sein. (Es sei denn, es ist in einen Nullable-Container verpackt).

Da es nicht null sein kann, enthält in einen numerischen Code und jeder Code ist einem Zeichen zugeordnet.

Keine Antwort auf Ihre Frage, aber um einen Standard zu kennzeichnen char, können Sie einfach verwenden

default(char)

das ist das gleiche wie char.MinValuedas wiederum ist das gleiche wie \0. Man sollte es jedoch nicht für so etwas wie eine leere Zeichenfolge verwenden.

Beantwortet Ihre erste Frage nicht - aber für das spezifische Problem, das Sie hatten, können Sie einfach Zeichenfolgen anstelle von Zeichen verwenden, oder?:

myString.Replace("c", "")

Gibt es einen Grund, warum Sie das nicht wollen?

Sie können Ihre Zeichenfolge auch zeichenweise neu erstellen, mit Ausnahme der Zeichen, die Sie entfernen möchten.

Hier ist eine Erweiterungsmethode, um dies zu tun:

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

Es ist nicht schick oder schick, aber es funktioniert gut.

Verwenden Sie wie folgt:

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

Wenn Sie Zeichen entfernen möchten, die eine bestimmte Bedingung erfüllen, können Sie Folgendes verwenden:

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

(Dadurch bleiben nur die Großbuchstaben in der Zeichenfolge.)

Mit anderen Worten, Sie können die Zeichenfolge als "verwenden" IEnumerable<char>, Änderungen daran vornehmen und sie dann wie oben gezeigt wieder in eine Zeichenfolge konvertieren.

Dies ermöglicht es wiederum, nicht nur ein bestimmtes Zeichen aufgrund des Lambda-Ausdrucks zu entfernen, sondern dies auch, wenn Sie den Lambda-Ausdruck folgendermaßen ändern : c => c != 't'.

Wie wäre es mit BOM , dem magischen Charakter, den Microsoft zum Start von Dateien hinzufügt (zumindest XML)?

Wenn Sie das leere Zeichen in der Zeichenfolge entfernen möchten, funktioniert Folgendes: Konvertieren Sie es einfach in eine beliebige Datentypdarstellung. Vielen Dank,

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 Bezug auf die C # -Sprache ist Folgendes möglicherweise nicht sehr sinnvoll. Und dies ist keine direkte Antwort auf die Frage. Aber Fowlloing ist das, was ich in einem meiner Geschäftsszenarien getan habe

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

Die nullund white spacehatten unterschiedliche Geschäftsabläufe in meinem Projekt. Beim Einfügen in die Datenbank muss ich empty stringin die Datenbank einfügen , wenn es sich um Leerzeichen handelt.

Ich weiß, dass dieser ziemlich alt ist, aber ich bin kürzlich auf ein Problem gestoßen, bei dem mehrere Ersetzungen vorgenommen werden mussten, um einen Dateinamen sicher zu machen. Erstens ist in der neuesten .NET-Zeichenfolge.Replace-Funktion null das Äquivalent zu einem leeren Zeichen. Was jedoch in .Net fehlt, ist ein einfaches Ersetzen aller Zeichen in einem Array durch das gewünschte Zeichen. Bitte verweisen Sie auf den folgenden Code (wird zum Testen in LinqPad ausgeführt).

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

    }

}

verwenden

myString.Replace ("c", "")

Der einfachste Weg, ein Zeichen pauschal aus der Zeichenfolge zu entfernen, besteht darin, es zuzuschneiden

cl = cl.Trim(' ');

Entfernt alle Leerzeichen in einer Zeichenfolge