c# - variable - string.IsNullOrEmpty(cadena) vs. string.IsNullOrWhiteSpace(cadena)

string null c#

Question

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

Answer 1

¡Dice que todo IsNullOrEmpty() no incluye espacio blanco mientras IsNullOrWhiteSpace() sí lo hace!

IsNullOrEmpty() Si la cadena es:
-Nulo
-Vacío

IsNullOrWhiteSpace() Si la cadena es:
-Nulo
-Vacío
-Contiene solo espacios en blanco

Answer 2

¿Qué tal esto para atrapar todo ...

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

Esto recortará todos los espacios si están allí evitando la penalización de rendimiento de IsWhiteSpace, que permitirá que la cadena cumpla la condición de "vacío" 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ás poniendo en una base de datos o algo así.

Answer 3

Aquí está la implementación real de ambos métodos (descompilado 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 4

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 otro espacio en blanco además de cadena vacía.

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

Referencia: Here

Para el rendimiento, IsNullOrWhiteSpace no es ideal, pero es bueno. Las llamadas al método darán lugar a una pequeña penalización de rendimiento. Además, el método IsWhiteSpace tiene algunos indirectos que se pueden eliminar si no está usando datos Unicode. Como siempre, la optimización prematura puede ser mala, pero también es divertida.

Referencia: Here

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

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: /

Answer 7

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

No considero usar ninguno de ellos como una mala práctica. La mayoría de las veces IsNullOrEmpty() es suficiente. Pero tienes la opción :)