C#学习日记30---泛型类、泛型方法、泛型委托

     泛型允许您延迟编写类或方法中的编程元素的数据类型的规范，直到实际在程序中使用它的时候。换句话说，在声明类或方法的时候由于不知道用户要传入什么样类型的参数，所以在传入类型的地方“挖一个坑（“＜Ｔ＞”）＂，使用它的时候我们再用具体数据类型填上。

泛型类：

　　根据前面所学知识我们定义一个类：

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

结果：　

 

 

       关于泛型就介绍这么多了，又什么错误的地方欢迎指出^_^