python 泛型编程 函数 泛型列表

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）返回一个类型的的默认值  ，一般在写泛型的时候   有可能用到

 }