String.IsNullOrBlank Método de extensión

Question

Compruebo continuamente los campos de cadena para comprobar si son nulos o están en blanco.

if(myString == null || myString.Trim().Length == 0) 
{ 
    throw new ArgumentException("Blank strings cannot be handled."); 
} 

Para ahorrarme un poco de tipeo ¿es posible crear un método de extensión para la clase String que tenga el mismo efecto? Entiendo cómo se pueden agregar los métodos de extensión para una instancia de clase, pero ¿qué pasa con agregar un método de extensión estática a una clase?

if(String.IsNullOrBlank(myString)) 
{ 
    throw new ArgumentException("Blank strings cannot be handled."); 
} 

Answer 1

Se podría hacer:

public static bool IsNullOrBlank(this String text) 
{ 
    return text==null || text.Trim().Length==0; 
} 

Y luego llamarlo así:

if(myString.IsNullOrBlank()) 
{ 
    throw new ArgumentException("Blank strings cannot be handled."); 
} 

Esto funciona porque C# le permite llamar método de extensión en los casos nulos.

Answer 2

¿Se pueden agregar métodos estáticos a las clases existentes? La respuesta es no, y el valor sería bastante bajo, porque aún necesitaría saber qué nombre de clase escribir primero; con los métodos de extensión, la ventaja es que comienza con un nombre de variable y la autocompletación le muestra cosas que le son aplicables.

Otro punto que se suele mencionar es que los métodos de extensión siempre deben arrojar una excepción lo antes posible si su primer argumento es nulo. Sin embargo, creo que esa regla es exagerada si el método menciona en su nombre que está diseñado para verificar null.

El verdadero problema que tiene es que quiere ejecutar código de forma clara y legible después de buscar una referencia nula. Una forma de capturar ese patrón es en my answer to this question.

Answer 3

Usted puede utilizar con seguridad un método de extensión en la instancia:

public static class StringExtensions 
{ 
    public static bool IsNullOrBlank(this string s) 
    { 
     return s == null || s.Trim().Length == 0; 
    } 
} 

Los casos de prueba:

string s = null; 
Assert.IsTrue(s.IsNullOrBlank()); 
s = " "; 
Assert.IsTrue(s.IsNullOrBlank()); 

se ve un poco raro sin embargo, y en lugar de eso se daría cuenta de por qué sus cuerdas necesitan ser revisado en este caso tan a menudo. Si los arreglas en la fuente, ¡no tendrás que ser tan paranoico sobre ellos más tarde!

Answer 4

public static bool IsNull(this object o) 
    { 
     return string.IsNullOrEmpty(o.ToStr()); 
    } 
    public static bool IsNotNull(this object o) 
    { 
     return !string.IsNullOrEmpty(o.ToStr()); 
    } 
    public static string ToStr(this object o) 
    { 
     return o + ""; 
    } 

Answer 5

public static bool IsNullOrEmptyTrimmed(string value) 
{ 
    return (value == null || value.Length == 0) ? 
     true : 
     value.Trim().Length == 0; 
} 

o

public static bool IsNullOrEmpty(this String value, bool checkTrimmed) 
{ 
    var b = String.IsNullOrEmpty(value); 
    return checkTrimmed ? (b && value.Trim().Length > 0) : b; 
} 

Answer 6

Bill Wagner en más eficaz C# recomienda en contra de hacer funciones de extensión trabajan con casos nulos (pp. 183).

La razón es que los métodos de extensión deben parecerse a las llamadas a métodos, y no puede llamar a un método con una instancia null.

Answer 7

Con un poco de ingenio, haces que parezca que haya agregado a la clasecadena en cualquier un archivo cs:

namespace JDanielSmith 
{ 
    public static class String 
    { 
     public static bool IsNullOrBlank(string text) 
     { 
      return text == null || text.Trim().Length == 0; 
     } 
    } 
} 

(nota, esto es no un método de extensión , mira mi comentario).

Entonces, en algún otro archivo CS:

using String = JDanielSmith.String; 
namespace Foo.Bar.Baz 
{ 
    class Program 
    { 
     static void test(string myString) 
     { 
      if (String.IsNullOrBlank(myString)) 
      { 
       throw new ArgumentException("Blank strings cannot be handled."); 
      } 
     } 
... 

Aviso la sintaxis "deseado" de String.IsNullOrBlank(). No estoy necesariamente sugiriendo que realmente hagas las cosas de esta manera, solo señalando cómo puedes configurar las cosas para hacer que tu código funcione.

Answer 8

Una sobrecarga a las respuestas existentes podrían ser:

public static bool IsNullOrBlank(this String text,Action<String> doWhat) 
{ 
    if (text!=null && text.Trim().Length>0) 
    doWhat(text); 
} 

sería útil si sólo desea ejecutar código dado un valor válido.

No es un ejemplo súper útil, pero sólo muestra el uso:

Name.IsNullOrBlank(name=>Console.WriteLine(name)); 

Answer 9

Sé que esto es una cuestión de edad, pero desde que fue golpeado y que no ha sido ya mencionado, a partir de .NET 4.0, simplemente puede usar String.IsNullOrWhiteSpace method para lograr el mismo resultado.

Answer 10

Un poco tarde. Pero también puedes poner el código para lanzar una excepción en un método de extensión también. Tengo dos métodos (para ArgumentNullException y NullReferenceException).

// strings 
public static bool NullBlankCheck(this string s, string message = "", 
    bool throwEx = true) 
{ 
    return Check<NullReferenceException>(s.IsNullOrBlank(), throwEx, message); 
} 
public static bool NullBlankCheckArgument(this string s, string message = "", 
    bool throwEx = true) 
{ 
    return Check<ArgumentException>(s.IsNullOrBlank(), throwEx, message); 
} 

private static bool Check<T>(bool isNull, bool throwEx, string exceptionMessage) 
    where T : Exception 
{ 
    if (throwEx && isNull) 
     throw Activator.CreateInstance(typeof(T), exceptionMessage) as Exception; 
    return isNull; 
} 

public static bool IsNullOrBlank(this string s) 
{ 
    return string.IsNullOrEmpty(s) || s.Trim().Length == 0; 
} 

pruebas NUnit:

Assert.Throws<NullReferenceException>(() => 
{ 
    "".NullEmptyCheck(); 
}); 
Assert.Throws<ArgumentException>(() => 
{ 
    "".NullEmptyCheckArgument(); 
}); 

Y luego usarlo como:

public void Method(string someStr) 
{ 
    someStr.NullBlankCheckArgument(); 
    // do something 
    var str = someMethod(); 
    str.NullBlankCheck(); 
}