string.IsNullOrEmpty (string) vs. string.IsNullOrWhiteSpace (string)

Wird die Verwendung string.IsNullOrEmpty(string)beim Überprüfen einer Zeichenfolge string.IsNullOrWhiteSpace(string)in .NET 4.0 und höher als schlechte Vorgehensweise angesehen ?

Die beste Vorgehensweise ist die Auswahl der am besten geeigneten.

.Net Framework 4.0 Beta 2 verfügt über eine neue IsNullOrWhiteSpace () -Methode für Zeichenfolgen, die die IsNullOrEmpty () -Methode so verallgemeinert, dass neben leeren Zeichenfolgen auch andere Leerzeichen enthalten sind.

Der Begriff „Leerraum“ umfasst alle Zeichen, die auf dem Bildschirm nicht sichtbar sind. Beispielsweise sind Leerzeichen, Zeilenumbruch, Tabulator und leere Zeichenfolge Leerzeichen * .

Referenz: Hier

Für die Leistung ist IsNullOrWhiteSpace nicht ideal, aber gut. Die Methodenaufrufe führen zu einer geringen Leistungsminderung. Darüber hinaus verfügt die IsWhiteSpace-Methode selbst über einige Indirektionen, die entfernt werden können, wenn Sie keine Unicode-Daten verwenden. Wie immer mag vorzeitige Optimierung böse sein, aber es macht auch Spaß.

Referenz: Hier

Überprüfen Sie den Quellcode (Referenzquelle .NET Framework 4.6.2)

IsNullorEmpty

[Pure]
public static bool IsNullOrEmpty(String value) {
    return (value == null || value.Length == 0);
}

IsNullOrWhiteSpace

[Pure]
public static bool IsNullOrWhiteSpace(String value) {
    if (value == null) return true;

    for(int i = 0; i < value.Length; i++) {
        if(!Char.IsWhiteSpace(value[i])) return false;
    }

    return true;
}

Beispiele

string nullString = null;
string emptyString = "";
string whitespaceString = "    ";
string nonEmptyString = "abc123";

bool result;

result = String.IsNullOrEmpty(nullString);            // true
result = String.IsNullOrEmpty(emptyString);           // true
result = String.IsNullOrEmpty(whitespaceString);      // false
result = String.IsNullOrEmpty(nonEmptyString);        // false

result = String.IsNullOrWhiteSpace(nullString);       // true
result = String.IsNullOrWhiteSpace(emptyString);      // true
result = String.IsNullOrWhiteSpace(whitespaceString); // true
result = String.IsNullOrWhiteSpace(nonEmptyString);   // false

Die Unterschiede in der Praxis:

string testString = "";
Console.WriteLine(string.Format("IsNullOrEmpty : {0}", string.IsNullOrEmpty(testString)));
Console.WriteLine(string.Format("IsNullOrWhiteSpace : {0}", string.IsNullOrWhiteSpace(testString)));
Console.ReadKey();

Result :
IsNullOrEmpty : True
IsNullOrWhiteSpace : True

**************************************************************
string testString = " MDS   ";

IsNullOrEmpty : False
IsNullOrWhiteSpace : False

**************************************************************
string testString = "   ";

IsNullOrEmpty : False
IsNullOrWhiteSpace : True

**************************************************************
string testString = string.Empty;

IsNullOrEmpty : True
IsNullOrWhiteSpace : True

**************************************************************
string testString = null;

IsNullOrEmpty : True
IsNullOrWhiteSpace : True

Sie sind verschiedene Funktionen. Sie sollten für Ihre Situation entscheiden, was Sie brauchen.

Ich halte es nicht für eine schlechte Praxis, einen von ihnen zu verwenden. Die meiste Zeit IsNullOrEmpty()ist genug. Aber du hast die Wahl :)

Hier ist die tatsächliche Implementierung beider Methoden (mit dotPeek dekompiliert)

[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
    public static bool IsNullOrEmpty(string value)
    {
      if (value != null)
        return value.Length == 0;
      else
        return true;
    }

    /// <summary>
    /// Indicates whether a specified string is null, empty, or consists only of white-space characters.
    /// </summary>
    /// 
    /// <returns>
    /// true if the <paramref name="value"/> parameter is null or <see cref="F:System.String.Empty"/>, or if <paramref name="value"/> consists exclusively of white-space characters.
    /// </returns>
    /// <param name="value">The string to test.</param>
    public static bool IsNullOrWhiteSpace(string value)
    {
      if (value == null)
        return true;
      for (int index = 0; index < value.Length; ++index)
      {
        if (!char.IsWhiteSpace(value[index]))
          return false;
      }
      return true;
    }

Es heißt, dass alles IsNullOrEmpty()keinen weißen Abstand enthält, während dies der IsNullOrWhiteSpace()Fall ist!

IsNullOrEmpty()Wenn die Zeichenfolge lautet:
-Null
-Empty

IsNullOrWhiteSpace()Wenn die Zeichenfolge lautet:
-Null
-Empty-
Enthält nur Leerzeichen

Überprüfen Sie dies mit IsNullOrEmpty und IsNullOrwhiteSpace

string sTestes = "I like sweat peaches";
    Stopwatch stopWatch = new Stopwatch();
    stopWatch.Start();
    for (int i = 0; i < 5000000; i++)
    {
        for (int z = 0; z < 500; z++)
        {
            var x = string.IsNullOrEmpty(sTestes);// OR string.IsNullOrWhiteSpace
        }
    }

    stopWatch.Stop();
    // Get the elapsed time as a TimeSpan value.
    TimeSpan ts = stopWatch.Elapsed;
    // Format and display the TimeSpan value. 
    string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
        ts.Hours, ts.Minutes, ts.Seconds,
        ts.Milliseconds / 10);
    Console.WriteLine("RunTime " + elapsedTime);
    Console.ReadLine();

Sie werden sehen, dass IsNullOrWhiteSpace viel langsamer ist: /

string.IsNullOrEmpty (str) - Wenn Sie überprüfen möchten, ob der Zeichenfolgenwert angegeben wurde

string.IsNullOrWhiteSpace (str) - im Grunde ist dies bereits eine Art Implementierung der Geschäftslogik (dh warum "" schlecht ist, aber so etwas wie "~~" ist gut).

Mein Rat - mischen Sie keine Geschäftslogik mit technischen Prüfungen. So ist beispielsweise string.IsNullOrEmpty am besten zu Beginn von Methoden zu verwenden, um ihre Eingabeparameter zu überprüfen.

Was ist damit für einen Fang alle ...

if (string.IsNullOrEmpty(x.Trim())
{
}

Dadurch werden alle Leerzeichen gekürzt, wenn sie vorhanden sind, wodurch die Leistungseinbußen von IsWhiteSpace vermieden werden. Dadurch kann die Zeichenfolge die Bedingung "leer" erfüllen, wenn sie nicht null ist.

Ich denke auch, dass dies klarer ist und es im Allgemeinen eine gute Praxis ist, Zeichenfolgen trotzdem zu kürzen, insbesondere wenn Sie sie in eine Datenbank oder etwas anderes einfügen.

Im .Net-Standard 2.0:

string.IsNullOrEmpty(): Gibt an, ob die angegebene Zeichenfolge null oder eine leere Zeichenfolge ist.

Console.WriteLine(string.IsNullOrEmpty(null));           // True
Console.WriteLine(string.IsNullOrEmpty(""));             // True
Console.WriteLine(string.IsNullOrEmpty(" "));            // False
Console.WriteLine(string.IsNullOrEmpty("  "));           // False

string.IsNullOrWhiteSpace(): Gibt an, ob eine angegebene Zeichenfolge null oder leer ist oder nur aus Leerzeichen besteht.

Console.WriteLine(string.IsNullOrWhiteSpace(null));     // True
Console.WriteLine(string.IsNullOrWhiteSpace(""));       // True
Console.WriteLine(string.IsNullOrWhiteSpace(" "));      // True
Console.WriteLine(string.IsNullOrWhiteSpace("  "));     // True