泛型类

1、类型是对象的模板，泛型不是类型，是类型的模板。c#提供五种泛型：类，结构，接口，委托和方法。

2、声明泛型类和普通类的区别

<1>在类名之后放置<>

<2>在<>中用逗号分隔的占位符字字符串表示提供的类型-类型参数(type parameter)

<3>在泛型类声明的主体中使用类型参数来表示应该被替代的类型

class Name<parameter1,paremeter2...>

{public parameter1 demo=new parameter1();...}

在泛型声明中没有特殊的关键词或标志

3、创建构造类型

用真实类型（类型实参）替代占位符，编译器获取这些真实类型并从它创建一个真实类型对象

class Name<type parameter> {},Name< type Argument>{}

如下：

泛型类声明:class Encounter<T1,T2>{T1 var1;T2 var2;},编译器接受类型实参，产生构造类型如：class Encounter<DateTime,string>{DateTime encounter;string Name;}

4、创建变量和实例:

<1>分配类变量：

class Encounter<DateTime,string>  justForYou;//在栈上为justForYou分配一个引用-null

<2>分配实例

justForYou=new Encounter<DateTime,string>();//在堆上分配实例，并且把引用赋值给变量JustForYou()，[原来是这样，所以声明引用类型，不对它初始化，直接使用它时编译器得到null,即表明堆中并没有关于它的数据的引用(reference=null),因此throw NullReferenceException]

 class Generic_Demo<T>
    {
        public int ArrayLength=5;
        public T[] PushItem;
        public int StackPointer = 0;
        public int StackMaxSize=10;
        public bool IsStackFull { get { return StackPointer > StackMaxSize; } }
        public bool IsStackEmpty { get { return StackPointer < 0; } }
        public T[] Push(T[] x)
        {
           PushItem = new T[x.Length];
            if (!IsStackFull)
            {
                for (int i = 0; i < x.Length; i++)
                {
                    PushItem[StackPointer++] = x[i];
                }

            }
            return PushItem;
        }
        public void Sorted(T[] array_Unsorted)
        {
          T  temp;
          T[] array_Sorted=new T[ArrayLength];
          for (int i = 0; i < ArrayLength-1; i++)
          {
              for (int j = 0; j < ArrayLength; j++)
              {
                  temp = array_Unsorted[i];
                  if ( Convert.ToInt16(array_Unsorted[i]) >Convert.ToInt16( array_Unsorted[i + 1]))
                  {
                      temp = array_Unsorted[i];
                      array_Unsorted[i] = array_Unsorted[i + 1];
                      array_Unsorted[i + 1] = temp;
                  }

              }
          }
          for (int k = 0; k < array_Unsorted.Length; k++)
          {
            array_Sorted[k] =  array_Unsorted[k];
          }
          Console.WriteLine("排序后数组:");
          for (int i = 0; i < array_Sorted.Length; i++)
          {
              Console.WriteLine("array_Sorted[{0}]:{1}", i,array_Sorted[i]);
          }

          Console.Read();
        }
    }

static void Main(string[] args)
{
  int[] arr = new int[]{ 3,1,2,8,6 };
            Generic_Demo<int> def = new Generic_Demo<int>();
            def.Push(arr);
            for (int i = 0; i < arr.Length; i++)
            {
                Console.WriteLine("{0}", def.PushItem[i]);
            }
            def.Sorted(def.PushItem);
            Console.Read();

}

.......后续更新....