Ejemplos de uso de genéricos en .Net (C#/VB.NET)

Question

¿Cuáles son algunos ejemplos de dónde usaría genéricos en C#/VB.NET y por qué le gustaría usar genéricos?

Answer 1

Simplemente, se declara un tipo o método de etiquetas adicionales para indicar los bits genéricos:

class Foo<T> { 
    public Foo(T value) { 
     Value = value; 
    } 
    public T Value {get;private set;} 
} 

Lo anterior define un tipo genérico de Foo "de T", donde el T es proporcionado por la persona que llama. Por convención, los argumentos de tipo genérico comienzan con T. Si sólo hay una, T está bien - de lo contrario nombrarlos a todos útilmente: TSource, TValue, etc TListType

A diferencia de las plantillas de C++, .NET genéricos son proporcionados por el tiempo de ejecución (no trucos del compilador). Por ejemplo:

Foo<int> foo = new Foo<int>(27); 

Todo T s han sido reemplazados con int en el anterior. Si es necesario, puede restringir argumentos genéricos con limitaciones:

class Foo<T> where T : struct {} 

Ahora Foo<string> se negará a compilar - como string no es una estructura (value-type). restricciones válidos son:

T : class // reference-type (class/interface/delegate) 
T : struct // value-type except Nullable<T> 
T : new() // has a public parameterless constructor 
T : SomeClass // is SomeClass or inherited from SomeClass 
T : ISomeInterface // implements ISomeInterface 

Las restricciones pueden afectar también otros argumentos de tipo genérico, por ejemplo:

T : IComparable<T> // or another type argument 

Puede tener tantos argumentos genéricos como sea necesario:

public struct KeyValuePair<TKey,TValue> {...} 

Otras cosas a tener en cuenta:

• s Los miembros táticos, etc. se definen como por combinación de tipo genérico - por lo que un campo estático en Foo<int> está separado del de Foo<float>.
• métodos pueden ser genéricos también - tratar de evitar el uso de los mismos nombres que utiliza la clase, ya que no será capaz de eliminar la ambigüedad
• tipos anidados heredan los tipos genéricos de sus padres

por ejemplo, :

class Foo<T> { 
    class Bar<TInner> {} // is effectively Bar<T,TInner>, for the outer T 
} 

Answer 2

Ejemplo 1: Usted desea crear el triple de clase

Class Triple<T1, T2, T3> 
{ 
    T1 _first; 
    T2 _second; 
    T3 _Third; 
} 

Exa MPLE 2: una clase de ayuda que analizar cualquier valor de enumeración para determinado tipo de datos

static public class EnumHelper<T> 
{ 
    static public T Parse(string value) 
    { 
     return (T)Enum.Parse(typeof(T), value); 
    } 
} 

Answer 3

Las razones más comunes y casos de uso para los genéricos están descritas en la documentación de MSDN mencionado antes. Un beneficio de los genéricos que me gustaría agregar es que pueden mejorar el soporte de la herramienta en el proceso de desarrollo. Las herramientas de refactorización, como las integradas en Visual Studio o ReSharper, se basan en análisis de tipo estático para proporcionar asistencia durante la codificación.Como los genéricos generalmente agregan más información de tipo a su modelo de objetos, hay más información para que dichas herramientas analicen y le ayuden a codificar.

En un nivel conceptual, los genéricos le ayudan a resolver inquietudes "transversales" independientemente del dominio de su aplicación. Sin importar si está desarrollando una aplicación financiera o una librería, tarde o temprano tendrá que mantener colecciones de cosas, ya sean cuentas, libros o lo que sea. La implementación de tales colecciones generalmente necesita saber poco o nada sobre las cosas que deben mantenerse en esas colecciones. Por lo tanto, las colecciones genéricas enviadas con .NET Framework son un ejemplo principal para un caso de uso de genéricos.

Answer 4

Un uso común, y extremadamente útil, de los genéricos es las clases de colección fuertemente tipadas. Tradicionalmente, todas las clases de colección tenían que pasar objetos y devolver objetos cuando se les consultaba. Tuviste que manejar todo el tipo de conversión tú mismo. Con los genéricos, no tienes que hacer eso. Puedes tener List (Of Integer), y cuando solicites valores de él, obtendrás enteros. No obtendrás objetos que luego tendrás que convertir en enteros.

Answer 5

private void button1_Click_1(object sender, RoutedEventArgs e) 
    { 
     TextValue<string, int> foo = new TextValue<string, int>("",0); 
     foo.Text = "Hi there"; 
     foo.Value = 3995; 
     MessageBox.Show(foo.Text); 
    } 

    class TextValue<TText, TValue> 
    { 
     public TextValue(TText text, TValue value) 
     { 
      Text = text; 
      Value = value; 
     } 
     public TText Text { get; set; } 
     public TValue Value { get; set; } 
    } 

Answer 6

private void button1_Click_1(object sender, RoutedEventArgs e) 
    { 
     TextValue<string, int> foo; 
     List<TextValue<string, int>> listTextValue = new List<TextValue<string, int>>(); 
     for (int k = 0; k < 5; ++k) 
     { 
      foo = new TextValue<string, int>("",0); 
      foo.Text = k.ToString(); 
      foo.Value = k; 
      listTextValue.Add(foo); 
      otherList. 
      MessageBox.Show(foo.Text); 
     } 

    } 

    class TextValue<TText, TValue> 
    { 
     public TextValue(TText text, TValue value){Text = text; Value = value;} 
     public TText Text { get; set; } 
     public TValue Value { get; set; } 
    } 

Answer 7

Un ejemplo básico sería:

class Other{ 
class Generic<T> 
{ 
    void met1(T x); 
} 
static void Main() 
{ 
    Generic<int> g = new Generic<int>(); 
    Generic<string> s = new Generic<string>(); 
} 
}