C#-Lerntagebuch 30 --- Generische Klassen, generische Methoden, generische Delegaten

Generika ermöglichen es Ihnen, das Schreiben der Spezifikation des Datentyps eines Programmierelements innerhalb einer Klasse oder Methode aufzuschieben, bis es tatsächlich in Ihrem Programm verwendet wird. Mit anderen Worten: Da wir beim Deklarieren einer Klasse oder Methode nicht wissen, welche Art von Parametern der Benutzer übergeben möchte, „graben wir ein Loch („＜Ｔ＞“)“, wo der Typ übergeben wird. Wenn wir Wenn Sie es verwenden, füllen wir es mit bestimmten Datentypen aus.

Generische Klasse:

Basierend auf dem Wissen, das wir zuvor gelernt haben, definieren wir eine Klasse:

　class Data
          {
              public int  n_data;
           }

Zu diesem Zeitpunkt der Datentyp von n_data wurde als int-Typ bestimmt, daher kann es beim Zuweisen eines Werts nur vom int-Typ sein, wenn es als die folgende generische Klasse umgeschrieben wird:

　

　class Data<T>
             {
               public T n_data;
             }

Zu diesem Zeitpunkt ist der Datentyp von n_data noch nicht sicher. Wenn Sie ihm also einen Wert zuweisen, müssen Sie T angeben, den Typ von n_data, der die Lücken füllen soll

　

　Data<int> data = new Data<int>();    //指定Ｔ为int
　　Data<string> data = new Data<string>();  //指定Ｔ为string

Im obigen Beispiel kann T natürlich nicht angegeben werden. Wenn der Typ von n_data ein Array sein soll, kann das folgende Beispiel erfüllt werden:

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Example  
{  
    class Data<T> //泛型类  
    {  
        public T[] n_data; //泛型变量  
       public Data(int size) //构造方法,new的时候调用构造方法开辟空间  
        {   
          n_data = new T[size];    
        }  
        //输入  
       public void setdata(int index,T value)  
       {  
           n_data[index] = value;  
       }  
        //输出  
       public T getdata(int x)  
       {   
          return n_data[x];  
       }  
    }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Data<int> data = new Data<int>(5);  
            data.n_data[2] = 2;  
           Console.WriteLine(data.n_data[2]);  
        }  
    }  
}

Das Ergebnis ist: 2

Generische Methode:

Das ist, was wir tun. Am Beispiel der Swap-Exchange-Methode wird die Swap-Funktion in C++ wie folgt geschrieben:

#include <iostream>  
  
using namespace std;  
template <typename T>  
void swap1(T &a,T &b)　//也可以看作泛型  
{  
  T temp;  
  temp = a;  
  a = b;  
  b = temp;  
}  
int main()  
{  
    int a=0,b=1;  
    swap1(a,b);  
    cout<<a<<"\t"<<b<<endl;  
 　　　　　return 0;  
}

Ergebnis: 1　0
Wenn a und b Zeichentypen sind, sind die oben genannten Funktionen ebenfalls anwendbar. Ｃ#swap-Methode lautet wie folgt:

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Example  
{  
    class data  
    {//swap方法，ref是按地址传递  
        public static void swap<T>(ref T a, ref T b)  
        {  
            T temp;  
            temp = a;  
            a = b;  
            b = temp;  
        }  
        static void Main(string[] args)  
        {  
            string a = "HC";  
            string b = "666";  
            swap(ref a,ref b);  
            Console.WriteLine(a+"\t"+b); //结果 666    HC  
        }  
    }  
}

Ergebnis: 666 HC Dies ist sehr ähnlich zu Ｃ＋＋

Generischer Delegat:

Dort delegieren sind auch Generika, folgend dem obigen Beispiel:

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Example  
{  
    public delegate void MyDelegate<T>();//泛型委托  
    class Data<T>  
    {  
        private T a;  
        private T b;  
        public void setvalue(T x, T y)  
        {  
            a = x;  
            b = y;  
        }  
        //swap方法，ref是按地址传递  
        public void swap()  
        {  
            T temp;  
            temp = a;  
            a = b;  
            b = temp;  
        }  
        public void printvalue()  
        {  
            Console.WriteLine(a + "\t" + b);  
  
        }  
  }  
      class program  
       {   
         static void Main(string[] args)  
          {  
            Data<string> data = new Data<string>();  
            data.setvalue("HC","666");  
            MyDelegate<string> my = new MyDelegate<string>(data.swap);  
            my += data.printvalue;  
            my();  //结果　６６６　　ＨＣ        
           }  
          
       }  
        
   }

Ergebnis:

Das ist alles über Generika, was sonst noch? Fehler beseitigen^_^

Das Obige ist der Inhalt von C# Learning Diary 30 – generische Klassen, generische Methoden und generische Delegaten. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.org). .php .cn)!