Generics C#

@GermanKuber
@NetBaires
http://germankuber.com.ar/perfil

• Agregados en la versión 2.0 de C#
• Concepto de parámetro de tipo
• Escribir clases con comportamiento genérico

• Maximizar la reutilización del código.
• Crear clases de colección.
• Crear interfaces, clases, métodos, eventos y delegados
genéricos.
• Habilitar el acceso a métodos en tipos de datos
determinados.
• Obtener información en tiempo de ejecución mediante la
reflexión.

• Garantiza la seguridad de tipos en tiempo de
compilación
• Escribir clases genéricas para tipos desconocidos

• Parámetros
• Clases
• Interfaces
• Métodos
• Delegados

• No se puede utilizar tal cual, porque no es realmente un
tipo, sino el plano de un tipo
• El argumento puede ser “cualquier” tipo conocido por el
compilador

public class GenericList<T>
{
public void Add(T item){ /*...*/ }
public void Remove(T item){ /*...*/ }
public IEnumerator<T> GetEnumerator(){ /*...*/ }
}

• Encapsulan operaciones que no son específicas de un tipo
de datos concreto
• Se utilizan frecuentemente con colecciones como listas
• Cuantos más tipos se puedan parametrizar, más
flexible y reutilizable será el código

class BaseNodeMultiple<T, U> { }
class Node4<T> : BaseNodeMultiple<T, int> { }
class Node5<T, U> : BaseNodeMultiple<T, U> { }

• Utilizar siempre las interfaces genéricas definidas por el
framework
• Una interfaz puede definir más de un parámetro de
tipo
• Las interfaces genéricas pueden heredar de interfaces
no genéricas si son contra-variantes

class Stack<T> where T : System.IComparable<T>,
IEnumerable<T> { }
interface IBaseInterface2<T, U> { }
class SampleClass1<T> : IBaseInterface1<T> { }
class SampleClass2<T> : IBaseInterface2<T, string> { }

• Se declara con parámetros de tipo
• Los métodos genéricos se pueden sobrecargar en varios
parámetros de tipo

class SampleClass<T>
{
void Swap(ref T lhs, ref T rhs) { /*...*/ }
void DoWork() { /*...*/ }
void DoWork<T>() { /*...*/ }
void DoWork<T, U>() { /*...*/ }
}

• Puede definir sus propios parámetros de tipo

class Stack<T>
{
T[] items;
public delegate void StackDelegate(T[] items);
delegate void StackEventHan<T, U>(T sender, U eventArgs);
public event SEventHan<Stack<T>, StackEvArgs> stackEvent;
}

{
public T GetLast()
{
T temp = default(T);
return temp;
}
}

• Aplicamos ciertas restricciones para limitar los tipos posibles de
nuestros genéricos
• El compilador generara error si se intenta utilizar un tipo que no
cumpla las restricciones
• Las restricciones se definen utilizando la palabra reservada
where

• No se pueden utilizar los operadores != ni ==
• Pueden convertirse a o desde System.Object
• Pueden convertirse explícitamente en cualquier tipo de interfaz
• Se pueden comparar con null.

Restricción
where T: struct
where T : class
where T : new()
where T : <nombre de clase base>
where T: <nombre de interfaz>
where T : U

public class Employee{}
where T : Employee{}
class Test<T, U>
where U : struct
where T : Employee, new() { }
void Add<U>(List<U> items) where U
: T {}

[CustomAttribute(info = typeof(GenericClass1<>))]
class ClassA { }
[CustomAttribute(info = typeof(GenericClass2<,>))]
class ClassB { }
[CustomAttribute(info = typeof(GenericClass3<int, double, string>))]
class ClassC { }

public class Person { /*...*/ }
public class Employee : Person { /*...*/ }
interface IRepository<T> { /*...*/ }
public class Repository<T> : IRepository<T>{}
void Each(IRepository<Person> p){ /*...*/ }
Each(new Repository<Employee>());

interface IRepository<out T> { /*...*/ }
void Each(IRepository<Person> p){ /*...*/ }
Each(new Repository<Employee>());

interface IRepository<T> { /*...*/ }
void Each(IRepository<Employee> p){ /*...*/ }
Each(new Repository<Person>());

interface IRepository<in T> { /*...*/ }
void Each(IRepository<Employee> p){ /*...*/ }
Each(new Repository<Person>());

Generics C#

Más contenido relacionado

La actualidad más candente (20)

Similar a Generics C# (20)

Más de Germán Küber (20)

Último (20)

Generics C#

Notas del editor