泛型及泛型应用

2012年4月21日   天气睛     天气说变就变   昨天天还阴阴沉沉  大雨倾盆  今天太阳高照   明天又是什么呢  不管了   坐在电脑旁   人都麻木了   今天有一朋友生日   正好出去转转  呼吸一下新鲜空气。

泛型及泛型应用：

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

namespace 泛型
{
    class Program
    {
        static void Main(string[] args)
        {
            DataContians<int> dc = new DataContians<int>();
            dc.Data = 2;
            //dc.Data = "ss";
            //普通类型转换为泛型
            ArrayList list = new ArrayList();
            list.Add(1);
            list.Add(2);
            list.Add(3);
            IEnumerable<int> l = list.Cast<int>();//进行转换
            foreach (int i in l)
            {
                Console.WriteLine(i);
            }

            //调用泛型方法
            Hello<int, string>(1, "sss");

            //泛型委托 调用 泛型方法
            Delegatestring<int,string> d = Hello<int, string>;
            d(1,"aaa");

            //泛型约束
            //泛型对于泛型委托  泛型类 都是一样的
            createlist<Dog>(3);//泛型无参约束
            personlist<person> p = new personlist<person>();//泛型继承约束
            personlist<chinese> p1 = new personlist<chinese>();

            //泛型约束之应用  可空类型
            int? nu = 3;//对于可空类型  系统会把他转换为Nullable<int>   Nullable<T>   int?编译器会自动翻译Nullable<int>
            if (nu.HasValue)
            {
                Console.WriteLine(nu.Value);
            }
            //用代码简单实现一下  可空类型   具体代码  往下看
            MyNullable<int> nul = new MyNullable<int>();
            nul.Hasvalue = true;
            nul.value = 3;
            //泛型应用之懒对象   Lazy<T>   vs2010才有的   为了提高性能尽量减少内存占用  一个对象没使用之前  不创建   等到使用时再创建   
            person p2 = new person();
            /*..一个对象在创建之后并没调用他，等执行一段代码之后再调用减少内存使用（理论上高性能）..*/
            /*一段代码执行*/
            p2.Hello();
            /*微软的方法*/
            //只有调用value时才调用类的构造函数
            //只有在该类非常耗内存的情况下  去使用
            //一般不使用
            Lazy<person> p3=new Lazy<person>();//在这里并没有调用构造 函数  可以 调试  测试一下
            /*一段代码执行*/
            p3.Value.Hello();//构造函数在此第一次调用  真的是懒对象

            //用泛型实现Lazy<T>
            MyLazy<person> p4 = new MyLazy<person>();
            p4.value.Hello();//完美实现   代码往下看  调试的时候  把上面的注释  Lazy注释悼

            Console.Read();
        }

        //泛型方法
        static void Hello<T,V>(T t,V v)
        {
            Console.WriteLine(v);
        }
        //public event EventHandler onshang;//泛型事件
        //泛型约束之无参约束
        static List<T> createlist<T>(int n) where T:new()//添加约束  约束为泛型构造函数为无参构造函数  好像只能约束无参的
        {
            List<T> list = new List<T>();
            for (int i = 0; i < n; i++)
            {
                T t = new T();//如果不加约束，他就会出错，因为他不确定是否有无参构建函数
                list.Add(t);
            }
            return list;
        }
    }
    //泛型约束之继承约束
    class personlist<T> where T : person//T的类型只能是person类或person类的子类
    {
    }
    public class DataContians<v>//约定一个特定类型
    {
        public v Data { get; set; }//所有用到类型的地方  可以用v代替
    }
    delegate void Delegatestring<T,T1>(T t,T1 t1);//泛型委托
    class Dog
    {
        public Dog()
        {
        }
    }
    class person
    {
   //     public int age;
        public person()
        {
            Console.WriteLine("被构造 了");
        }
        public void Hello()
        {
            Console.WriteLine("Hello");
        }
    }
    class chinese : person
    {

    }
    class MyNullable<T> where T : struct
    {
        public bool Hasvalue{get;set;}
        public T value { get; set; }
    }
    class MyLazy<T> where T:new()
    {
        private T instance;
        public T value
        {
            get
            {
                if(instance==null)
                {
                    instance=new T();
                }
                return instance;
            }
        }
    }//default（T）返回一个类型的的默认值  ，一般在写泛型的时候   有可能用到

}