C# - Generiek

Algemeen stelt u in staat om de specificatie van het datatype van programmeerelementen in een klasse of een methode te definiëren, totdat het daadwerkelijk in het programma wordt gebruikt. Met andere woorden, generieke methoden stellen u in staat een klasse of methode te schrijven die met elk gegevenstype kan werken.

Je schrijft de specificaties voor de klasse of de methode, met vervangende parameters voor datatypes. Wanneer de compiler een constructor voor de klasse of een functieaanroep voor de methode tegenkomt, genereert deze code om het specifieke gegevenstype te verwerken. Een eenvoudig voorbeeld zou helpen om het concept te begrijpen −

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();
      }
   }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

0 5 10 15 20
a b c d e

Kenmerken van Generics

Generiek is een techniek die uw programma's op de volgende manieren verrijkt −

• Het helpt u het hergebruik van code, de typeveiligheid en de prestaties te maximaliseren.

• U kunt generieke verzamelingsklassen maken. De klassenbibliotheek van .NET Framework bevat verschillende nieuwe generieke verzamelingsklassen in de System.Collections.Generic naamruimte. U kunt deze generieke verzamelklassen gebruiken in plaats van de verzamelklassen in de System.Collections naamruimte.

• U kunt uw eigen generieke interfaces, klassen, methoden, evenementen en afgevaardigden maken.

• U kunt generieke klassen maken die beperkt zijn om toegang tot methoden voor bepaalde gegevenstypen mogelijk te maken.

• U kunt tijdens runtime informatie krijgen over de typen die worden gebruikt in een generiek gegevenstype door middel van reflectie.

Algemene methoden

In het vorige voorbeeld hebben we een generieke klasse gebruikt; we kunnen een generieke methode declareren met een typeparameter. Het volgende programma illustreert het concept −

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();
      }
   }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

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

Algemene afgevaardigden

U kunt een generieke gemachtigde definiëren met typeparameters. Bijvoorbeeld −

delegate T NumberChanger<T>(T n);

Het volgende voorbeeld toont het gebruik van deze gemachtigde −

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();
      }
   }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

Value of Num: 35
Value of Num: 175