Generics

Generischer Klassen / Methoden

Alle Folgenden Beispiele sind auch auf Methoden anwendbar, auch wenn die Klasse nicht Generisch ist...

public class ClassA<T>{
    private int Wert1;        // Normaler WErt
    private T Wert2;          // Wert vom übergebenen Typ
    private T[] Wertarray;    // Array vom übergebenen Typ

    public ClassA()
    { ...
    }

    Public void Change(T element, int idx)
    {    Wertarray[idx] = element;    // Dirty Bsp... ohne Rücksicht auf Verluste!
        ...
    }

}

static void Main(string[] args){
    ClassA<string> MyStringClass = new Class<A>(); 
    ... 

Mehrere Typeparamter

public class Dictionary<K,V>{
    public void Add(K key, V value) { .... }
    public V this[K key] { ..... }
}

static void Main(string[] args){
    Dictionary<int, MyClass> myDict = new Dictionary<int, MyClass>

    myDict.Add(1, new MyClass() );

    MyClass cls = myDict[1];
    ... 

null Rückgabe Wert oder Referenz??

Damit bei Werten Rückgabe = 0 und Referenzen Rückgabe = null ist

public class Sammlung<K,V>{
    private <V>[] Elements;

    public V this[K key]{
        get{
            if(key > Size){
                return default<V>;    // gibt bei WErtpara 0 und bei Refpara null zurück;
            }else{
                return Elements[key];
            }
        }
        set{...
        }
    }
}

Einschränkungen / Constraints

public class SortList<T>{
    T[] arr = new T[100];

    public T[] Add(T element){
        for(int i=0; i<arr.Length; i++)
            int reslut = ((ICompareable element).CompareTo(arr[i]); // KANN EXCEPTION VERURSCHEN!!

// RICHTIG:

public class SortList<R> where T: ICompareable{
    T[] arr = new T[100];
    public T[] Add(Telement){
        for(int i=0; i<arr.Length; i++)
            int result = element.CompareTo(arr[i]);    // auch kein Cast nötig für CompareTo, da fixiert

Mehrere Constraints:

....
    public Void MyMethod<T,K>
                            where T : IComparable, ICLoneable
                            where K : SomeBaseClass
    {....

Konstruktor Contraint

Ist nur mit Parameterlosen Konstruktoren möglich;

public class MyClass<K,V> where V : new(){    // Bedingung, dass V einen Parameterlosen Konstruktor hat
    public K key = default(K);    // k = null oder 0
    public V value;

    public MyClass(){
        value = new V();    // Aufruf des parameterlosen Konstruktor
    }
}

Konvertierung

~~~~~
// Version mit Constraints:
class ClassB<t> where T : Class A, ICompareable{
public void MyMethod(T obj){
ICopareable var1 = obj; // möglich durch Constraint
ClassA var2 = obj; // möglich durch Constraint
Object var3 = obj; // möglich, weil Typ Object immer mögich ist
}
}</t>

// Version ohne Constraints, aber Casten:
class ClassB<t>{
public void MyMethod(T obj){
ICopareable var1 = (ICompareable)obj; // casten zu SCHNITTSTELLEN ist möglich
ClassA var2 = (ClassA) obj; // !!FEHLER!! casten zu ALLGEMEINEN KLASSEN ist NICHT MÖGLICH
Object var3 = obj; // möglich, weil Typ Object immer mögich ist
}
}</t>