Restricciones genéricas en la función

Question

Quiero escribir una función genérica que tenga una restricción sobre el tipo. Específicamente quiero algo como esto:

bool IsInList<T>(T value, params T[] args) 
{ 
    bool found = false; 
    foreach(var arg in args) 
    { 
     if(arg == value) 
     { 
      found = true; 
      break; 
     } 
    } 
    return found; 
} 

El punto es que se puede comprobar si un elemento está en una lista de parámetros a saber:

if(IsInList("Eggs", "Cheese", "Eggs", "Ham")) 

Sin embargo, el compilador estira la pata en la línea de igualdad. Así que quiero poner una restricción sobre el tipo que implementa IEquatable. Sin embargo, las restricciones solo parecen funcionar en el nivel de clase. ¿Es correcto o hay alguna forma de especificar esto genéricamente?

Answer 1

limitaciones genéricas trabajan en métodos genéricos, así:

bool IsInList<T>(T value, params T[] args) where T : IEquatable<T> 

PERO, IEquatable<T> no define operator ==, solamente Equals(T).

Por lo tanto, debe usar Equals() y ni siquiera necesita la restricción para eso: Equals(object) es miembro de object.

Además, no olvide que Equals no funcionará si el objeto es null.

Answer 2

El operador `== 'se usa generalmente para tipos inmutables solamente (tipos de valores incorporados o tipos inmutables personalizados que han sobrecargado el operador ==. A menos que lo sobrecargue, si lo usa en tipos de referencia, (excepto cadenas) solo devuelve verdadero si ambas variables apuntan a la misma instancia del tipo (mismo objeto). Devolvería falso si los dos verificables apuntan a instancias diferentes del tipo incluso si ambos tienen todos los mismos valores de datos internos.

Necesita restringir el tipo T a los tipos que implementan la función Equals(), que está destinada a determinar si dos instancias de cualquier tipo son "iguales" y no solo que ambas apuntan a la misma instancia ... y use eso en su lugar. La interfaz integrada IEquatable<T> expresa esto para usted. (Un poco como IComparable<T> requiere que un tipo tiene una función CompareTo())
También, usted puede hacer su función mucho más concisa y clara ...

intente esto:

bool IsInList<T>(T value, params T[] args) where T:IEquatable<T> 
{ 
    foreach(var arg in args)   
     if(value.Equals(arg)) return true; 
    return false; 
} 

También debe entender la diferencia entre Equals() y == y decida cuál es más apropiado para cualquiera que sea su intención ... Consulte la referencia this para obtener más información.

Answer 3

basta con sustituir

arg == value 

con

arg.Equals(value) 

Answer 4

Otros han mencionado IEquatable<T> que sin duda es una buena restricción de potencial.

Otra opción para recordar es EqualityComparer<T>.Default, que usará IEquatable<T> si está disponible, pero retroceda a object.Equals(object) de lo contrario.Esto significa que se puede utilizar con los tipos de los cuales son anteriores a los genéricos, pero anulan Equals, por ejemplo:

bool IsInList<T>(T value, params T[] args) 
{ 
    IEqualityComparer<T> comparer = EqualityComparer<T>.Default; 
    bool found = false; 
    foreach(var arg in args) 
    { 
     if(comparer.Equals(arg, value)) 
     { 
      found = true; 
      break; 
     } 
    } 
    return found; 
} 

Tenga en cuenta que el comparador de igualdad predeterminado también se enfrenta con referencias nulas, por lo que no necesita preocuparse por los mismo. Si el tipo de T no ha anulado o object.Equals(object) implementado IEquatable<T>, obtendrá la semántica de igualdad de referencia (es decir, que sólo devolverá true si la referencia exacta es en la matriz).

Algunos otros puntos:

• su deseo de adherirse a un solo punto de salida hace que el código menos legible, la OMI. No hay necesidad de una variable adicional aquí:

  bool IsInList<T>(T value, params T[] args) 
  { 
      IEqualityComparer<T> comparer = EqualityComparer<T>.Default; 
      foreach (var arg in args) 
      { 
       if (comparer.Equals(arg, value)) 
       { 
        return true; 
       } 
      } 
      return false; 
  } 
  

• LINQ ya contiene un método para esto, Contains, por lo que puede simplificar el código para:

  bool IsInList<T>(T value, params T[] args) 
  { 
      return args.Contains(value); 
  } 
  

• Array contiene efectivamente esta funcionalidad también, con IndexOf:

  bool IsInList<T>(T value, params T[] args) 
  { 
      return Array.IndexOf(args, value) != -1; 
  } 
  

• Su método es tal vez una litt le nombre engañoso, dado que args es una matriz, no un List<T>.