Mi primer método de extensión, ¿podría escribirse mejor?

Question

Debido a que este es mi primer intento de un método de extensión que parece bastante útil para mí, sólo quiero para asegurarse de que voy por el camino de la derecha

public static bool EqualsAny(this string s, string[] tokens, StringComparison comparisonType) 
    { 
     foreach (string token in tokens) 
     { 
      if (s.Equals(token, comparisonType)) 
      { 
       return true; 
      } 
     } 

     return false; 
    } 

Llamado por

if (queryString["secure"].EqualsAny(new string[] {"true","1"}, StringComparison.InvariantCultureIgnoreCase)) 
{ 
    parameters.Protocol = Protocol.https; 
} 

EDITAR: Algunas sugerencias excelentes que vienen, exactamente el tipo de cosa que estaba buscando. Gracias

EDIT:

me he decidido por la siguiente implementación

public static bool EqualsAny(this string s, StringComparison comparisonType, params string[] tokens) 
{ 
    // for the scenario it is more suitable for the code to continue 
    if (s == null) return false; 

    return tokens.Any(x => s.Equals(x, comparisonType)); 
} 

public static bool EqualsAny(this string s, params string[] tokens) 
{ 
    return EqualsAny(s, StringComparison.OrdinalIgnoreCase, tokens); 
} 

he preferido usar params sobre IEnumerable porque simplifica el código de llamada

if (queryString["secure"].EqualsAny("true","1")) 
{ 
    parameters.Protocol = Protocol.https; 
} 

algo muy distinto de el anterior

if (queryString["secure"] != null) 
{ 
    if (queryString["secure"] == "true" || queryString["secure"] == "1") 
    { 
     parameters.Protocal = Protocal.https; 
    } 
} 

¡Gracias de nuevo!

Answer 1

public static bool EqualsAny(
    this string s, 
    StringComparison comparisonType, 
    params string[] tokens) 
{ 
    foreach (string token in tokens) 
    { 
     if (s.Equals(token, comparisonType)) 
     { 
      return true; 
     } 
    } 
    return false; 
} 

Con params, no es necesario forzar primero las cadenas en una matriz.

var match = "loool".EqualsAny(StringComparison.Ordinal, "hurf", "Durf"); 

LINQ-cado (JC + me) con un (norma marco) NRE:

public static bool EqualsAny(
    this string s, 
    StringComparison comparisonType, 
    params string[] tokens) 
{ 
    if(s == null) throw new NullReferenceException("s"); 
    return tokens.Any(x=> s.Equals(x, comparisonType)); 
} 

Answer 2

Haga que su parámetro tokens sea más general, es decir, conviértalo en IEnumerable<string>.

Además, ya existe un método equivalente que se extiende a IEnumerable<>, p. Ej. Any:

public static bool EqualsAny(this string s, IEnumerable<string> tokens, StringComparison comparisonType) 
{ 
    return tokens.Any(t => s.Equals(t, comparisonType)); 
} 

Además, Joel es, por supuesto derecha: es posible que desee comprobar si hay null valores antes de realizar las acciones (codificación defensiva). Esto no es más seguro, pero hace que el error sea más fácil de localizar.

Answer 3

con el fin de simplificar el uso de EqualsAny podría utilizar varargs y la estrategia predeterminada para StringComparison:

public static bool EqualsAny(this string s, params string[] tokens) { 
    return EqualsAny(s, StringComparison.InvariantCultureIgnoreCase, tokens); 
} 

public static bool EqualsAny(this string s, 
          StringComparison stringComparison, 
          params string[] tokens) { 
    // your method 
} 

llamado por

if (queryString["secure"].EqualsAny("true", "1")) { 
    parameters.Protocol = Protocol.https; 
} 

Answer 4

Sí! Primero, debe verificar s para nulo. Además, deje que se acepta ninguna IEnumerable<string> de fichas en lugar de sólo una matriz, y luego usar otros operadores LINQ para hacer el registro de entrada:

public static bool EqualsAny(this string s, IEnumerable<string> tokens, StringComparison comparisonType) 
{ 
    if (s== null) return false; 
    return tokens.Any(t => s.Equals(t, comparisonType)); 
} 

---

Pensando en cómo manejar un valor null de s, hay una tercera opción que nadie ha utilizado aún:

public static bool EqualsAny(this string s, IEnumerable<string> tokens, StringComparison comparisonType) 
{ 
    if (s== null) return tokens.Any(t => t == null); 
    return tokens.Any(t => s.Equals(t, comparisonType)); 
} 

---

Por último, en cuanto a su aplicación elegido: si va a tener sobrecargas, que también podría tener la sobr IEnumerable ds también, y haz que tu código params los llame.

Answer 5

Otra opción sería. Esto simplificará su sitio de llamadas ya que si tiene un par de cadenas su correspondencia contra usted no tendrá que crear la matriz o lista en el código.

public static bool EqualsAny(this string s,StringComparison comparisonType, param string[] tokens) 
{ 
    return EqualsAny(s,comparisonType,tokens); 
}  

public static bool EqualsAny(this string s,StringComparison comparisonType, IEnumerable<string>tokens)  
{ 
    //Throw nullReference to keep the semantics aligned with calling an instance member 
    if (s==null) throw new NullReferenceException();  
    foreach (string token in tokens)   
    {    
     if (s.Equals(token, comparisonType))    
     {     
      return true;    
     }   
    }   
    return false;  

} 

Answer 6

No hay nada de malo en sí con lo que estás haciendo. Sin embargo, este tipo de funcionalidad ya existe en varias formas diferentes.

Ejemplo:

var candidates = List<SomeObject>(); 
if (candidates.Count(c=> string.Compare(c.PropertyValue, queryString["secure"], StringComparison.InvariantCultureIgnoreCase) == 0) > 0) 
{ 
parameters.Protocol = Protocol.https; 
}