Saltar al contenido

Artículos, tutoriales, trucos, curiosidades, reflexiones y links sobre programación web ASP.NET Core, MVC, Blazor, SignalR, Entity Framework, C#, Azure, Javascript... y lo que venga ;)

18 años online

el blog de José M. Aguilar

Inicio El autor Contactar

Artículos, tutoriales, trucos, curiosidades, reflexiones y links sobre programación web
ASP.NET Core, MVC, Blazor, SignalR, Entity Framework, C#, Azure, Javascript...

¡Microsoft MVP!
martes, 18 de noviembre de 2008
Código fuenteLos métodos genéricos son interesantes herramientas que están con nosotros desde los tiempos del .NET Framework 2.0 y pueden resultarnos muy útiles de cara a la construcción de frameworks o librerías reutilizables.

Podríamos considerar que un método genérico es a un método tradicional lo que una clase genérica a una tradicional; por tanto, se trata de un mecanismo de definición de métodos con tipos parametrizados, que nos ofrece la potencia del tipado fuerte en sus parámetros y devoluciones aun sin conocer los tipos concretos que utilizaremos al invocarlos.

Vamos a profundizar en el tema desarrollando un ejemplo, a través del cual podremos comprender por qué los métodos genéricos pueden sernos muy útiles para solucionar determinado tipo de problemas, y describiremos ciertos aspectos, como las restricciones o la inferencia, que nos ayudarán a sacarles mucho jugo.

Escenario de partida

Como sabemos, los métodos tradicionales trabajan con parámetros y retornos fuertemente tipados, es decir, en todo momento conocemos los tipos concretos de los argumentos que recibimos y de los valores que devolvemos. Por ejemplo, en el siguiente código, vemos que el método Maximo, cuya misión es obvia, recibe dos valores integer y retorna un valor del mismo tipo:
  public int Maximo(int uno, int otro)
{
if (uno > otro) return uno;
return otro;
}
 
Hasta ahí, todo correcto. Sin embargo, está claro que retornar el máximo de dos valores es una operación que podría ser aplicada a más tipos, prácticamente a todos los que pudieran ser comparados. Si quisiéramos generalizar este método y hacerlo accesible para otros tipos, se nos podrían ocurrir al menos dos formas de hacerlo.

La primera sería realizar un buen puñado de sobrecargas del método para intentar cubrir todos los casos que se nos puedan dar:
  public int Maximo(int uno, int otro) { ... }
public long Maximo(long uno, long otro) { ... }
public string Maximo(string uno, string otro) { ... }
public float Maximo(float uno, float otro) { ... }
// Hasta que te aburras...
 
Obviamente, sería un trabajo demasiado duro para nosotros, desarrolladores perezosos como somos. Además, según Murphy, por más sobrecargas que creáramos seguro que siempre nos faltaría al menos una: justo la que vamos a necesitar ;-).

Otra posibilidad sería intentar generalizar utilizando las propiedades de la herencia. Es decir, si asumimos que tanto los valores de entrada del método como su retorno son del tipo base object, aparentemente tendríamos el tema resuelto. Lamentablemente, al finalizar nuestra implementación nos daríamos cuenta de que no es posible hacer comparaciones entre dos object's, por lo que, o bien incluimos en el cuerpo del método código para comprobar que ambos sean comparables (consultando si implementan IComparable), o bien elevamos el listón de entrada a nuestro método, así:
  public object Maximo(IComparable uno, object otro)
{
if (uno.CompareTo(otro) > 0) return uno;
return otro;
}
 
Pero efectivamente, como ya habréis notado, esto tampoco sería una solución válida para nuestro caso. En primer lugar, el hecho de que ambos parámetros sean object o IComparable no asegura en ningún momento que sean del mismo tipo, por lo que podría invocar el método enviándole, por ejemplo, un string y un int, lo que provocaría un error en tiempo de ejecución. Y aunque es cierto que podríamos incluir código que comprobara que ambos tipos son compatibles, ¿no tendríais la sensación de estar llevando a tiempo de ejecución problemática de tipado que bien podría solucionarse en compilación?

El método genérico

Fijaos que lo que andamos buscando es simplemente alguna forma de representar en el código una idea conceptualmente tan sencilla como: "mi método va a recibir dos objetos de un tipo cualquiera T, que implemente IComparable, y va a retornar el que sea mayor de ellos". En este momento es cuando los métodos genéricos acuden en nuestro auxilio, permitiendo definir ese concepto como sigue:
  public T Maximo<T>(T uno, T otro) where T: IComparable
{
if (uno.CompareTo(otro) > 0) return uno;
return otro;
}
 
En el código anterior, podemos distinguir el parámetro genérico T encerrado entre ángulos "<" y ">", justo después del nombre del método y antes de comenzar a describir los parámetros. Es la forma de indicar que Maximo es genérico y operará sobre un tipo cualquiera al que llamaremos T; lo de usar esta letra es pura convención, podríamos llamarlo de cualquier forma (por ejemplo MiTipo Maximo<MiTipo>(MiTipo uno, MiTipo otro)), aunque ceñirse a las convenciones de codificación es normalmente una buena idea.

A continuación, podemos observar que los dos parámetros de entrada son del tipo T, así como el retorno de la función. Si no lo ves claro, sustituye mentalmente la letra T por int (por ejemplo) y seguro que mejora la cosa.

Lógicamente, estos métodos pueden presentar un número indeterminado de parámetros genéricos, como en el siguiente ejemplo:
  public TResult MiMetodo<T1, T2, TResult>(T1 param1, T2 param2)
{
// ... cuerpo del método
}
 

Restricciones en parámetros genéricos

Retomemos un momento el código de nuestro método genérico Maximo:
  public T Maximo<T>(T uno, T otro) where T: IComparable
{
if (uno.CompareTo(otro) > 0) return uno;
return otro;
}
 
Vamos a centrarnos ahora en la porción final de la firma del método anterior, donde encontramos el código where T: IComparable. Se trata de una restricción mediante la cual estamos indicando al compilador que el tipo T podrá ser cualquiera, siempre que implementente el interfaz IComparable, lo que nos permitirá realizar la comparación.

Existen varios tipos de restricciones que podemos utilizar para limitar los tipos permitidos para nuestros métodos parametrizables:
  • where T: struct, indica que el argumento debe ser un tipo valor.
  • where T: class, indica que T debe ser un tipo referencia.
  • where T: new(), fuerza a que el tipo T disponga de un constructor público sin parámetros; es útil cuando desde dentro del método se pretende instanciar un objeto del mismo.
  • where T: nombredeclase, indica que el argumento debe heredar o ser de dicho tipo.
  • where T: nombredeinterfaz, el argumento deberá implementar el interfaz indicado.
  • where T1: T2, indica que el argumento T1 debe ser igual o heredar del tipo, también argumento del método, T2.
Un último detalle relativo a esto: a un mismo parámetro se pueden aplicar varias restricciones, en cuyo caso se separarán por comas, como aparece en el siguiente ejemplo:
  public TResult MiMetodo<T1, T2, TResult>(T1 param1, T2 param2)
where TResult: IEnumerable
where T1: new(), IComparable
where T2: IComparable, ICloneable
{
// ... cuerpo del método
}
 
En cualquier caso, las restricciones no son obligatorias. De hecho, sólo debemos utilizarlas cuando necesitemos restringir los tipos permitidos como parámetros genéricos, como en el ejemplo del método Maximo<T>, donde es la única forma que tenemos de asegurarnos que las instancias que nos lleguen en los parámetros puedan ser comparables.

Uso de métodos genéricos

A estas alturas ya sabemos, más o menos, cómo se define un método genérico, pero nos falta aún conocer cómo podemos consumirlos, es decir, invocarlos desde nuestras aplicaciones. Aunque puede intuirse, la llamada a los métodos genéricos debe incluir tanto la tradicional lista de parámetros del método como los tipos que lo concretan. Vemos unos ejemplos:
  string mazinger = Maximo<string>("Mazinger", "Afrodita");  
int i99 = Maximo<int>(2, 99);
 
Una interesantísima característica de la invocación de estos métodos es la capacidad del compilador para inferir, en muchos casos, los tipos que debe utilizar como parámetros genéricos, evitándonos tener que indicarlos de forma expresa. El siguiente código, totalmente equivalente al anterior, aprovecha esta característica:
  string mazinger = Maximo("Mazinger", "Afrodita");  
int i99 = Maximo(2, 99);
 
El compilador deduce el tipo del método genérico a partir de los que estamos utilizando en la lista de parámetros. Por ejemplo, en el primer caso, dado que los dos parámetros son string, puede llegar a la conclusión de que el método tiene una signatura equivalente a string Maximo(string, string), que coincide con la definición del genérico.

Otro ejemplo de método genérico

Veamos un ejemplo un poco más complejo. El método CreaLista, aplicable a cualquier clase, retorna una lista genérica (List<T>) del tipo parametrizado del método, que rellena inicialmente con los argumentos (variables) que se le suministra:
  public List<T> CreaLista<T>(params T[] pars)
{
List<T> list = new List<T>();
foreach (T elem in pars)
{
list.Add(elem);
}
return list;
}

// ...
// Uso:

List<int> nums = CreaLista<int>(1, 2, 3, 4, 6, 7);
List<string> noms = CreaLista<string>("Pepe", "Juan", "Luis");
 
Otros ejemplos de uso, ahora beneficiándonos de la inferencia de tipos:
  List<int> nums = CreaLista(1, 2, 3, 4, 6, 7);
List<string> noms = CreaLista("Pepe", "Juan", "Luis");

// Incluso con tipos anónimos de C# 3.0:
var p = CreaLista(
new { X = 1, Y = 2 },
new { X = 3, Y = 4 }
);
Console.WriteLine(p[1].Y); // Pinta "4"
 
En resumen, se trata de una característica de la plataforma .NET, reflejada en lenguajes como C# y VB.Net, que está siendo ampliamiente utilizada en las últimas incorporaciones al framework, y a la que hay que habituarse para poder trabajar eficientemente con ellas.

Publicado en: www.variablenotfound.com.

20 Comentarios:

Anónimo dijo...

¡Muy buen post! Sigue así, para los que estramos empezando es una maravilla encontrar información tan clara.

Salu2. Ramiro.

Julio Trujillo Leon dijo...

Estupenda aclaración.

Soy desarrollador de VB.NET ¿tenemos algo parecido en VB?

Gracias

josé M. Aguilar dijo...

Gracias por vuestros comentarios.

@Julio: pues sí, con VB.NET también puedes utilizar métodos genéricos, aunque "traducidos" a su propia sintaxis. Si te parece, escribiré este mismo post, con todos sus ejemplos adaptados para Visual Basic.

Saludos.

Anónimo dijo...

hola, yo tambien programo en visual y me gustaría saber más sobre los metodos genericos en este lenguaje. gracias.

enhorabuena por el blog.

Anónimo dijo...

"Variable not found" entro a mis blogs de revisión diaria. Muy claro y muy util.

Saludos

Unknown dijo...

Gracias!!! me sirvió muchisimo! justo que estoy arrancando a trabajar me viene muy bien~! slds

Anónimo dijo...

Muy buen post!

Hernaldo Gonzalez dijo...

Muy buena y clarisima explicación, le paga patada a la información oficial:

http://msdn.microsoft.com/es-es/library/twcad0zb(v=vs.80).aspx

saludos y gracias!!

Javier Guerrero dijo...

Muy bien explicado. Gracias.

Unknown dijo...
Este comentario ha sido eliminado por el autor.
Joseba dijo...

Hola!

Y sería posible inferir un return del tipo:

return new { codigo = "OK", texto = "Lo que sea" };

para que sea devuelto por una función

¿Alguna idea? Gracias.

Joseba dijo...

Bueno, después de escudriñar un poco por ahí he visto que hacer algo así, para poder manejar el tipo anónimo devuelto, a parte de un pelín laborioso, no merece la pena.

Saludos.

José María Aguilar dijo...

Hola,

Me temo no se puede inferir el tipo de algo que no tiene tipo (bueno, o es desconocido en tiempo de desarrollo) ;D

Si necesitas poder acceder limpiamente a las propiedades del tipo retornado, quizás tu solución pueda ir por retornar tipos dinámicos (dynamic), estructuras clave-valor, o bien usar tipos reales, es decir, de la forma:

return new MiTipo(){ codigo="OK", texto="Lo que sea");


Saludos!

Joseba dijo...

Sí, al final he optado por crearme un clase y no complicarme la existencia.
He mirado Tuple pero no me ha convencido.
Gracias y saludos.

LuisLAP dijo...

@Joseba, no mires Tuple, mira ValueTuple, esos si que molan, y mucho.

José María Aguilar dijo...

Yeah ;)

http://www.variablenotfound.com/2017/06/tuplas-en-c-7.html

Unknown dijo...

Buenas:

A ver si alguien me orienta. Pongo un ejemplo para explicarme:

public class MiClase
{
public int Numero { get; set; }
public string Nombre { get; set; }

public MiClase()
{
Numero = 1;
Nombre = "";
}

public MiClase(int numero, string nombre)
{
Numero = numero;
Nombre = nombre;
}
}

class Program
{
public static T Crear(int numero, string nombre) where T : new()
{
return new T();
}

static void Main(string[] args)
{
var a = Crear(5, "pepe");
}
}

Esto a priori funciona aunque no hace nada inteesante.

Mi cuetión es ¿cómo podría hacer algo similar pero pasando los parámetros al constructor de la clase (en este caso genérica de la función Crear)?

return new T(numero, nombre);

Un saludo.

Unknown dijo...

Se come los menor que y mayor que

public static T Crear(AQUI T)(int numero, string nombre) where T : new()
{
return new T();
}

José María Aguilar dijo...

Hola!

No estoy seguro de haberte entendido bien, pero si es lo que creo, me temo que no puede realizarse. La restricción new() en el parámetro genérico requiere que exista un constructor sin parámetros, pero no hay una forma de usarlo luego pasándole parámetros.

Por tanto, tendrías que buscar alternativas como:
1) enviar un delegado al método Crear que sea quien levante la instancia
2) usar reflexión (?)

Saludos!

Joseba dijo...

Hola!

Si no me equivoco, a día de hoy con c#, no se puede instanciar un tipo genérico con parámetrros en el constructor.

Si lo que quieres en imstamciar una clase "anónima" con parámetros, echa un vistazo a Assembly.CreateInstance y Activator.CreateInstance.
Aunque esas practicas penalizan el rendimiento.

Un saludo.