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

Question

¿Se usa string.IsNullOrEmpty(string) al verificar una cadena considerada como una mala práctica cuando hay string.IsNullOrWhiteSpace(string) en .NET 4.0 y superior?

Answer 1

La mejor práctica es seleccionar la más adecuada.

.Net Framework 4.0 Beta 2 tiene un nuevo método IsNullOrWhiteSpace() para cadenas que generaliza el método IsNullOrEmpty() para incluir también otra espacio en blanco, además de cadena vacía.

El término "espacio en blanco" incluye todos los caracteres que no están visibles en la pantalla . Por ejemplo, el espacio, el salto de línea, la pestaña y la cadena vacía son blancos caracteres de espacio *.

Referencia: Here

Para obtener un rendimiento, IsNullOrWhiteSpace no es lo ideal, pero es buena. Las llamadas al método darán lugar a una pequeña penalización de rendimiento. Además, el método IsWhiteSpace en sí tiene algunas indirecciones que pueden eliminarse si no está utilizando datos Unicode. Como siempre, la optimización prematura de puede ser mala, pero también es divertida.

Referencia: Here

Comprobar el código fuente (Fuente de referencia de .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; 
} 

Ejemplos

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 

Answer 2

Son funciones diferentes. Debes decidir para tu situación qué necesitas.

No considero que utilizar ninguna de ellas sea una mala práctica. La mayoría de las veces IsNullOrEmpty() es suficiente. Pero tiene la opción :)

Answer 3

¿Y esto para toda una captura ...

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

Esto recortar todos los espacios si están allí para evitar la pérdida de rendimiento de IsWhiteSpace, lo que permitirá la cadena para cumplir la condición "vacía" si no es nula.

También creo que esto es más claro y, en general, es una buena práctica para ajustar cadenas de todos modos, especialmente si los está poniendo en una base de datos o algo así.

Answer 4

Aquí es la aplicación real de ambos métodos (descompilada usando 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; 
    } 

Answer 5

Las diferencias en la práctica:

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 

Answer 6

lo dice todo IsNullOrEmpty() no incluye el espaciamiento blanco, mientras que IsNullOrWhiteSpace() hace!

IsNullOrEmpty() Si la cadena es:
-null
-Empty

IsNullOrWhiteSpace() Si la cadena es:
-null
-Empty
Espacios -Contiene blanco solamente

Answer 7

mira esto con IsNullOrEmpty e 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(); 

Verás que IsNullOrWhiteSpace es mucho más lento:/