泛型-----------C#

 class Program
    {
        static void Main(string[] args)
        {
            nihao<Int32> i = new nihao<Int32>();
            //使用这个类中的add方法
            i.Add(1);

            i.WriteStill();
            Console.Write(i.Add_3<int>(3));
            Console.ReadKey();
        }
    }

    //模仿List的泛型类型
    //where T : struct | T必须是一个结构类型
    //where T : class T必须是一个类（class）类型
    //where T : new() | T必须要有一个无参构造函数
    //where T : NameOfBaseClass | T必须继承名为NameOfBaseClass的类
    //where T : NameOfInterface | T必须实现名为NameOfInterface的接口
    //where T : Stream | T必须实现名为NameOfInterface的接口
    public class nihao<T> where T : struct
    {  //T只是使类型看起来直观，其实并没有什么实际作用


        //这是一个存储变量的字段
        private List<T> Current;
        public nihao()
        {
            Current = new List<T>();
        }

        public void WriteStill()
        {
            foreach (T nini in Current)
            {
                Console.Write(nini);
            }
        }

        public bool Add(T MYT)
        {
            Current.Add(MYT);
            return true;
        }

        //泛型方法,TS和T的效果一样。。。只是为了做参数的类型限定，，这样可以增加方法传参的灵活性
        public string Add_3<TS>(TS I) where TS : struct
        { 
            TS t = I;
            return t.ToString();
        }

    }

 2.以上的泛型T是不能用new实例化的类型，，，要实例化的话，首先得是继承与class，还有继承new(),例如

 public sealed class DoubleSearch<T> where T : class, new()
    {
        //这个对象引用一个单实例对象
        private static T s_value=null ;

        //私有化，防止外部实例化
        private DoubleSearch()
        {

        }

        public static T GetSingleton()
        {
            //如果对象已经创建，就直接返回（这样速度很快）
            if (s_value != null) return s_value;

            //创建一个实例对象，并把它固定下来
            T temp = new T();
            Interlocked.CompareExchange(ref s_value,temp,null);
            //这个技术的缺点是，，在多个线程同时访问这个方法时，会实例化多个对象。。。
            //但是，这种情况几乎不会发生。。。。
            //就算发生， 多创建的实例，之后也会被释放掉
            return s_value;
        }
    }