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

Apakah penggunaan string.IsNullOrEmpty(string)saat memeriksa string dianggap sebagai praktik buruk ketika ada string.IsNullOrWhiteSpace(string)di .NET 4.0 dan di atasnya?

Praktik terbaik adalah memilih yang paling tepat.

.Net Framework 4.0 Beta 2 memiliki metode IsNullOrWhiteSpace () baru untuk string yang menggeneralisasi metode IsNullOrEmpty () untuk juga memasukkan ruang putih lain selain string kosong.

Istilah "ruang putih" mencakup semua karakter yang tidak terlihat di layar. Misalnya, spasi, pemisah baris, tab, dan string kosong adalah karakter spasi putih * .

Referensi: Di Sini

Untuk kinerja, IsNullOrWhiteSpace tidak ideal tetapi bagus. Panggilan metode akan menghasilkan penalti kinerja kecil. Lebih lanjut, metode IsWhiteSpace itu sendiri memiliki beberapa tipuan yang dapat dihapus jika Anda tidak menggunakan data Unicode. Seperti biasa, optimasi prematur mungkin jahat, tetapi juga menyenangkan.

Referensi: Di Sini

Periksa kode sumber (Sumber Referensi .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;
}

Contohnya

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

Perbedaan dalam praktik:

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

Mereka adalah fungsi yang berbeda. Anda harus memutuskan untuk situasi Anda apa yang Anda butuhkan.

Saya tidak menganggap menggunakan salah satu dari mereka sebagai praktik yang buruk. Sebagian besar waktu IsNullOrEmpty()sudah cukup. Tapi Anda punya pilihan :)

Berikut ini adalah implementasi sebenarnya dari kedua metode (didekompilasi menggunakan dotPeek)

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

Ia mengatakan itu semua IsNullOrEmpty()tidak termasuk spasi putih sementara IsNullOrWhiteSpace()!

IsNullOrEmpty()Jika string:
-Null
-Empty

IsNullOrWhiteSpace()Jika string:
-Null
-Empty
-Berisi Ruang Putih Saja

Lihat ini dengan IsNullOrEmpty dan 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();

Anda akan melihat bahwa IsNullOrWhiteSpace jauh lebih lambat: /

string.IsNullOrEmpty (str) - jika Anda ingin memeriksa nilai string telah disediakan

string.IsNullOrWhiteSpace (str) - pada dasarnya ini sudah semacam implementasi logika bisnis (yaitu mengapa "" buruk, tetapi sesuatu seperti "~~" baik).

Saran saya - jangan gabungkan logika bisnis dengan pemeriksaan teknis. Jadi, misalnya, string.IsNullOrEmpty adalah yang terbaik untuk digunakan di awal metode untuk memeriksa parameter input mereka.

Bagaimana dengan ini untuk menangkap semua ...

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

Ini akan memangkas semua ruang jika ada di sana menghindari hukuman kinerja IsWhiteSpace, yang akan memungkinkan string untuk memenuhi kondisi "kosong" jika bukan nol.

Saya juga berpikir ini lebih jelas dan umumnya merupakan praktik yang baik untuk memangkas string, terutama jika Anda memasukkannya ke dalam database atau sesuatu.

Dalam. Net standard 2.0:

string.IsNullOrEmpty(): Menunjukkan apakah string yang ditentukan adalah null atau string Kosong.

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

string.IsNullOrWhiteSpace(): Menunjukkan apakah string yang ditentukan adalah null, kosong, atau hanya terdiri dari karakter spasi putih.

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