chuỗi.IsNullOrEmpty (chuỗi) so với chuỗi.IsNullOrWhiteSpace (chuỗi)

Được sử dụng string.IsNullOrEmpty(string)khi kiểm tra một chuỗi được coi là thực tiễn xấu khi có string.IsNullOrWhiteSpace(string)trong .NET 4.0 trở lên?

Thực hành tốt nhất là chọn một cách thích hợp nhất.

.Net Framework 4.0 Beta 2 có một phương thức IsNullOrWhiteSpace () mới cho các chuỗi tổng quát hóa phương thức IsNullOrEmpty () để bao gồm cả khoảng trắng khác bên cạnh chuỗi trống.

Thuật ngữ không gian trắng xóa trực tuyến, bao gồm tất cả các ký tự không hiển thị trên màn hình. Ví dụ: dấu cách, dấu ngắt dòng, tab và chuỗi trống là các ký tự khoảng trắng * .

Tham khảo: Tại đây

Về hiệu suất, IsNullOrWhiteSpace không lý tưởng nhưng tốt. Các cuộc gọi phương thức sẽ dẫn đến một hình phạt hiệu suất nhỏ. Hơn nữa, bản thân phương thức IsWhiteSpace có một số chỉ dẫn có thể được loại bỏ nếu bạn không sử dụng dữ liệu Unicode. Như mọi khi, tối ưu hóa sớm có thể là xấu xa, nhưng nó cũng rất vui.

Tham khảo: Tại đây

Kiểm tra mã nguồn (Tham chiếu nguồn .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;
}

Ví dụ

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

Sự khác biệt trong thực tế:

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

Chúng là các chức năng khác nhau. Bạn nên quyết định cho tình huống của bạn những gì bạn cần.

Tôi không coi việc sử dụng bất kỳ trong số họ là một thực hành xấu. Hầu hết thời gian IsNullOrEmpty()là đủ. Nhưng bạn có quyền lựa chọn :)

Đây là cách triển khai thực tế của cả hai phương thức (dịch ngược bằng 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;
    }

Nó nói rằng tất cả IsNullOrEmpty()không bao gồm khoảng cách màu trắng trong khi IsNullOrWhiteSpace()không!

IsNullOrEmpty()Nếu chuỗi là:
-Null
-Empty

IsNullOrWhiteSpace()Nếu chuỗi là:
-Null
-Empty -Chỉ duy nhất
Spaces trắng

Kiểm tra điều này với IsNullOrEmpty và 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();

Bạn sẽ thấy IsNullOrWhiteSpace chậm hơn nhiều: /

chuỗi.IsNullOrEmpty (str) - nếu bạn muốn kiểm tra giá trị chuỗi đã được cung cấp

chuỗi.IsNullOrWhiteSpace (str) - về cơ bản đây đã là một dạng triển khai logic nghiệp vụ (nghĩa là tại sao "" là xấu, nhưng một cái gì đó như "~ ~" là tốt).

Lời khuyên của tôi - không trộn lẫn logic kinh doanh với kiểm tra kỹ thuật. Vì vậy, ví dụ, string.IsNullOrEmpty là cách tốt nhất để sử dụng ở đầu các phương thức để kiểm tra các tham số đầu vào của chúng.

Thế còn cái này để bắt tất cả ...

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

Điều này sẽ cắt tất cả các khoảng trắng nếu chúng ở đó tránh hình phạt hiệu năng của IsWhiteSpace, điều này sẽ cho phép chuỗi đáp ứng điều kiện "trống" nếu nó không rỗng.

Tôi cũng nghĩ rằng điều này rõ ràng hơn và thực tế nó thường tốt để cắt các chuỗi dù thế nào, đặc biệt nếu bạn đang đặt chúng vào cơ sở dữ liệu hoặc một cái gì đó.

Trong tiêu chuẩn .Net 2.0:

string.IsNullOrEmpty(): Cho biết chuỗi được chỉ định là null hay chuỗi rỗng.

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

string.IsNullOrWhiteSpace(): Cho biết một chuỗi được chỉ định là null, trống hoặc chỉ bao gồm các ký tự khoảng trắng.

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