c#泛型的实际应用

对于一些不太确定的类型， 可以使用泛型，这可以编写一个和任何类型工作的类或者方法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _12Generic
{
  //泛型类
    class GenericArray<T>
    {
        private T[] array;
        private int length;
        
        public GenericArray(int size)
        {
            array = new T[size + 1];
            length = size;
        }
       public int Length
        {
            get
            {
                return length;
            }
            set {
                length = value;
            }
        }
        public T GetT(int index)
        {
            return array[index];
        }
        public bool setItem(int index, T value)
        {
            if (index < 0 || index >= array.Length)
                return false;
            else
            {
                array[index] = value;
                return true;
            }
        }
    }

    class Program
    {
        //泛型函数
        public static  void swap<T>(ref T a, ref T b)
        {
            T temp;
            temp = a;
            a = b;
            b = temp;
        }

        static void Main(string[] args)
        {
            GenericArray<int> array_i=new GenericArray<int>(5);
            array_i.setItem(0, 5);
            array_i.setItem(1, 3);
            array_i.setItem(2, 4);
            array_i.setItem(3, 8);
            array_i.setItem(4, 8);
            int a = 1;
            int b = 2;
            Console.WriteLine("before a:{0},b:{1}", a, b);
            swap(ref a, ref b);
            Console.WriteLine("after a:{0},b:{1}", a, b);
            GenericArray<char> array_c = new GenericArray<char>(3);
            array_c.setItem(0, 'a');
            array_c.setItem(1, 'b');
            array_c.setItem(2, 'c');
            for (int i = 0; i < array_i.Length; i++)
            {
                Console.WriteLine(array_i.GetT(i).ToString());
            }
            for (int i = 0; i < array_c.Length; i++)
            {
                Console.WriteLine(array_c.GetT(i));
            }
        }
    }
}

泛型限定条件：

•  T：结构（类型参数必须是值类型。可以指定除 Nullable 以外的任何值类型）
•  T：类 （类型参数必须是引用类型，包括任何类、接口、委托或数组类型）
•  T：new() （类型参数必须具有无参数的公共构造函数。当与其他约束一起使用时new() 约束必须最后指定）
•  T：<基类名> 类型参数必须是指定的基类或派生自指定的基类
•  T：<接口名称> 类型参数必须是指定的接口或实现指定的接口。可以指定多个接口约束。约束接口也可以是泛型的。