Een van de vernieuwingen sinds C# 2.0 is de mogelijkheid om met generics te werken. De term generic betekent geparameteriseerde types. Door het gebruik van generics kan je klassen, interfaces en methoden maken die op een type-safe manier werken met verschillende datatypes. Met generics kan je een algoritme één keer ontwerpen en gebruiken voor verschillende gegevenstypes.

In dit eerste eenvoudig voorbeeld maken we een consoletoepassing die het gebruik van generics demonstreert.

• Start een nieuw Project in Visual Studio 2005: C# - Windows - Console application
  • Name: eenvoudigvoorbeeld
  • Kies een locatie
  • Solution name: Generics
  • Maak een map voor de solution
• Voeg een nieuwe Class-library toe aan de solution: MyGenerics
• Voeg aan MyGenerics een nieuwe Class-file Gen.cs toe

  using System;
  using System.Collections.Generic;
  using System.Text;
  
  namespace MyGenerics
  {
      // Een eenvoudige generic klasse
  
      using System;
      /* *****************************************
       * In de klasse Gen is T een type-parameter
       * die zal vervangen worden door een echt type
       * wanneer een object van het type Gen wordt
       * gemaakt
       * ******************************************/
      public class Gen<T>
      {
          T ob; // declareert een object van het type T
  
          // de constructor heeft een parameter van het type T
          public Gen(T o)
          {
              ob = o;
          }
  
          // Retourneer ob, van het type T
          public T getob()
          {
              return ob;
          }
  
          // Toon het type van T
          public void showType()
          {
              Console.WriteLine("Type van T is " + typeof(T));
          }
      }
  
  }
  

• Leg vanuit de console-app een referentie naar MyGenerics
• Voorzie in de Main methode van de Console-app:

  using System;
  using System.Collections.Generic;
  using System.Text;
  using MyGenerics;
  
  namespace eenvoudigvoorbeeld
  {
      class Program
      {
          static void Main(string[] args)
          {
              // We maken een object van de klasse Gen met type int
              Gen<int> iOb;
  
              // Maak een Gen<int> object en stel de referentie in op iOb
              iOb = new Gen<int>(102);
              
              // Toon type van iOb
              Console.WriteLine(iOb.GetType());
              // Toon het type van data in iOb
              iOb.showType();
  
              // Toon de waarde van iOb
              int v = iOb.getob();
              Console.WriteLine("waarde: " + v +"\n\n");
    
              // Maak een Gen object, type string
              Gen<string> strOb = new Gen<string>("Werken met Generics");
  
              // Toon het datatype van strOb
              Console.WriteLine(strOb.GetType());
              // Toon het datatype gestockeerd in strOb
              strOb.showType();
  
              // Toon de waarde van strOb
              string str = strOb.getob();
              Console.WriteLine("waarde: " + str +"\n\n");
          }
      }
  }
  
  

• Voer uit met ctrl-F5

Bespreking:

• De klasse Gen wordt als volgt gedeclareerd:

  public class Gen<T>
  {
  	...
  }
  

  Hier is T de naam van een typeparameter: deze naam wordt gebruikt als plaatshouder van het echte gegevenstype dat zal worden opgegeven wanneer een object wordt aangemaakt. Binnen de klasse Gen wordt T telkens gebruikt wanneer dit gegevenstype wordt aangegeven. Het declareren van een typeparameter gebeurt tussen < en >. Doordat de klasse Gen een typeparameter gebruikt spreken we van een Generic Class.

  Het gebruik van de letter T is louter volgens conventie om als eerste typeparameter T te gebruiken, je mag gerust een andere letter of zelfs een meer beschrijvend woord gebruiken.

• Een object ob van het type T wordt aangemaakt:

  T ob;
  

• De constructor:

  public Gen(T o)
  {
      ob = o;
  }
  

  In de constructor ontvangen we een argument van het type T en kennen dat toe aan de variabele ob van onze klasse. In onze klasse is het nu dus zo dat wanneer we als parametertype voor T bvb. int kiezen, we een int moeten meegeven bij aanmaak van een object. Vanzelfsprekend kan je een generic class ook voorzien van een argumentloze constructor, of een andere constructor door overloading

  public Gen() { }
  

• In de console-app maken we een object van de klasse Gen met type int:

  Gen<int> iOb;
  

  Hier geven we op dat voor deze versie van Gen de typeparameter T telkens het type int zal voorstellen.
• De volgende regel kent een referentie naar een instantie van een int-versie van de Gen-klasse aan iOb toe.

  iOb = new Gen<int>(102);
  

  Het type van de parameter moet natuurlijk dezelfde zijn als bij aanmaak van het iOb-object:

  iOb = new Gen<double>(118.12); // Error!
  

• Generic types verschillen naargelang hun typeargumenten:

  iOb = strOb; //Error!
  

• Voeg volgende klasse toe aan de Class-library MyGenerics:

  public class TweeGen<T, V>
  {
      T ob1;
      V ob2;
  
  
      public TweeGen(T o1, V o2)
      {
          ob1 = o1;
          ob2 = o2;
      }
  
  
      public void showTypes()
      {
          Console.WriteLine("Type van T is " + typeof(T));
          Console.WriteLine("Type van V is " + typeof(V));
      }
  
      public T getob1()
      {
          return ob1;
      }
  
      public V getob2()
      {
          return ob2;
      }
  }
  

• Voorzie de methode Main van de consoletoepassing van volgende code:

  static void Main(string[] args)
  {
  
      TweeGen<int, string> tgObj =
      new TweeGen<int, string>(119, "Alpha Beta Gamma");
  
      // Toon objecttype
      Console.WriteLine(tgObj.GetType());
  
      // Toon types van typeparameters
      tgObj.showTypes();
  
      // toon waarden
      int v = tgObj.getob1();
      Console.WriteLine("waarde: " + v);
  
      string str = tgObj.getob2();
      Console.WriteLine("waarde: " + str);
  
  }
  

  Opmerking: het is niet omdat je in de klasse TweeGen twee verschillende typeparameters T en V gebruikt dat je verplicht bent verschillende gegevenstypes te gebruiken:

  TweeGen<int, int> tgObj =
      new TweeGen<int, int>(119, 12);
  

  is correct !

Soms is het nuttig om de mogelijke types te beperken.
Dit kan je doen door constraints op te geven aan de typeparameters:

class klassenaam<typeparameterlijst> where typeparameter : constraints 
{ 
	...
}

Base class constraint

class Test<T> where T : A

• Voeg de klassen A, B, C en de generische klasse Test toe aan de Class Library MyGenerics:

  Gen.cs
  public class A
  {
      public void Hallo()
      {
           Console.WriteLine("Hallo");
      }
  }
  
  // Klasse B erft over van A
  public class B : A { }
  
  // Klasse C erft niet over van A
  public class C { }
  
  // Generische klasse Test
  public class Test<T> where T : A
  {
      T obj;
  
      public Test(T o)
      {
          obj = o;
      }
  
      public void ZegHallo()
      {
          // Ok om de methode Hallo aan te roepen
          // aangezien T overerft van A
          obj.Hallo();
      }
  }
  

• De methode Main van de console-applicatie:

  A a = new A();
  B b = new B();
  C c = new C();
  
  // Geldig daar A de basisklasse is
  Test<A> t1 = new Test<A>(a);
  t1.ZegHallo();
  
  // Geldig daar B overerft van A
  Test<B> t2 = new Test<B>(b);
  
  t2.ZegHallo();
  
  // Ongeldig daar C niet overerft van A
  // Test<C> t3 = new Test<C>(c); // Error!