C# - Genéricos

Genéricos le permiten definir la especificación del tipo de datos de los elementos de programación en una clase o un método, hasta que se utilice realmente en el programa. En otras palabras, los genéricos le permiten escribir una clase o un método que puede funcionar con cualquier tipo de datos.

Escribe las especificaciones para la clase o el método, con parámetros sustitutos para los tipos de datos. Cuando el compilador encuentra un constructor para la clase o una llamada de función para el método, genera código para manejar el tipo de datos específico. Un ejemplo simple ayudaría a entender el concepto −

Demostración en vivo

using System;
using System.Collections.Generic;

namespace GenericApplication {
   public class MyGenericArray<T> {
      private T[] array;
      
      public MyGenericArray(int size) {
         array = new T[size + 1];
      }
      public T getItem(int index) {
         return array[index];
      }
      public void setItem(int index, T value) {
         array[index] = value;
      }
   }
   class Tester {
      static void Main(string[] args) {
         
         //declaring an int array
         MyGenericArray<int> intArray = new MyGenericArray<int>(5);
         
         //setting values
         for (int c = 0; c < 5; c++) {
            intArray.setItem(c, c*5);
         }
         
         //retrieving the values
         for (int c = 0; c < 5; c++) {
            Console.Write(intArray.getItem(c) + " ");
         }
         
         Console.WriteLine();
         
         //declaring a character array
         MyGenericArray<char> charArray = new MyGenericArray<char>(5);
         
         //setting values
         for (int c = 0; c < 5; c++) {
            charArray.setItem(c, (char)(c+97));
         }
         
         //retrieving the values
         for (int c = 0; c< 5; c++) {
            Console.Write(charArray.getItem(c) + " ");
         }
         Console.WriteLine();
         
         Console.ReadKey();
      }
   }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −

0 5 10 15 20
a b c d e

Características de los genéricos

Generics es una técnica que enriquece sus programas de las siguientes maneras −

• Le ayuda a maximizar la reutilización del código, la seguridad de tipos y el rendimiento.

• Puede crear clases de colección genéricas. La biblioteca de clases de .NET Framework contiene varias clases de colección genéricas nuevas en System.Collections.Generic espacio de nombres Puede usar estas clases de colección genéricas en lugar de las clases de colección en System.Collections espacio de nombres.

• Puede crear sus propias interfaces genéricas, clases, métodos, eventos y delegados.

• Puede crear clases genéricas restringidas para habilitar el acceso a métodos en tipos de datos particulares.

• Puede obtener información sobre los tipos utilizados en un tipo de datos genérico en tiempo de ejecución por medio de la reflexión.

Métodos genéricos

En el ejemplo anterior, hemos usado una clase genérica; podemos declarar un método genérico con un parámetro de tipo. El siguiente programa ilustra el concepto −

Demostración en vivo

using System;
using System.Collections.Generic;

namespace GenericMethodAppl {
   class Program {
      static void Swap<T>(ref T lhs, ref T rhs) {
         T temp;
         temp = lhs;
         lhs = rhs;
         rhs = temp;
      }
      static void Main(string[] args) {
         int a, b;
         char c, d;
         a = 10;
         b = 20;
         c = 'I';
         d = 'V';
         
         //display values before swap:
         Console.WriteLine("Int values before calling swap:");
         Console.WriteLine("a = {0}, b = {1}", a, b);
         Console.WriteLine("Char values before calling swap:");
         Console.WriteLine("c = {0}, d = {1}", c, d);
         
         //call swap
         Swap<int>(ref a, ref b);
         Swap<char>(ref c, ref d);
         
         //display values after swap:
         Console.WriteLine("Int values after calling swap:");
         Console.WriteLine("a = {0}, b = {1}", a, b);
         Console.WriteLine("Char values after calling swap:");
         Console.WriteLine("c = {0}, d = {1}", c, d);
         
         Console.ReadKey();
      }
   }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −

Int values before calling swap:
a = 10, b = 20
Char values before calling swap:
c = I, d = V
Int values after calling swap:
a = 20, b = 10
Char values after calling swap:
c = V, d = I

Delegados genéricos

Puede definir un delegado genérico con parámetros de tipo. Por ejemplo −

delegate T NumberChanger<T>(T n);

El siguiente ejemplo muestra el uso de este delegado −

Demostración en vivo

using System;
using System.Collections.Generic;

delegate T NumberChanger<T>(T n);
namespace GenericDelegateAppl {
   class TestDelegate {
      static int num = 10;
      
      public static int AddNum(int p) {
         num += p;
         return num;
      }
      public static int MultNum(int q) {
         num *= q;
         return num;
      }
      public static int getNum() {
         return num;
      }
      static void Main(string[] args) {
         //create delegate instances
         NumberChanger<int> nc1 = new NumberChanger<int>(AddNum);
         NumberChanger<int> nc2 = new NumberChanger<int>(MultNum);
         
         //calling the methods using the delegate objects
         nc1(25);
         Console.WriteLine("Value of Num: {0}", getNum());
         
         nc2(5);
         Console.WriteLine("Value of Num: {0}", getNum());
         Console.ReadKey();
      }
   }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −

Value of Num: 35
Value of Num: 175