C#进修日志30---泛型类、泛型要领、泛型托付【C#.Net教程】,泛型类、泛型方法、泛型委托

泛型许可您耽误编写类或要领中的编程元素的数据范例的范例，直到现实在顺序中使用它的时刻。换句话说，在声明类或要领的时刻因为不知道用户要传入什么样范例的参数，所以在传入范例的处所“挖一个坑（“＜Ｔ＞”）＂，使用它的时刻我们再用详细数据范例填上。

泛型类：

　　依据前面所学学问我们定义一个类：

　class Data
          {
              public int  n_data;
           }

此时n_data的数据范例已肯定为int范例，所认为他赋值的时刻只能为int 范例，假如改写为下面的泛型类：

　class Data<T>
             {
               public T n_data;
             }

此时n_data的数据范例还不肯定是什么范例，所认为他赋值的时刻须要指定Ｔ也就是n_data的范例,也就是填坑，

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

固然了，上面的例子中是不能够指定Ｔ为数组的，假如要让n_data的范例为数组的话，下面的例子能够满足：

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

效果为：２

泛型要领：

　　　这个我们以swap交流要领为例，在Ｃ++中swap函数是这么写的：

#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;  
}

效果：　１　　０
假如ａ与ｂ是字符范例以上函数也实用。Ｃ＃swap要领以下：

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  
        }  
    }  
}

效果：666 HC 这与Ｃ＋＋的却是很类似啊

泛型托付：

　　托付也有泛型的，接着上面的例子：　

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();  //效果　６６６　　ＨＣ        
           }  
          
       }  
        
   }

效果：