泛型

泛型目的：约束容器中能放何种类型的数据，使编程变成类型安全的了。如：

•对比ArrayList和List<T>，ArrayList中的数据放进去以后再拿出来都是object标签，因此需要类型转换，而且很难阻止非法类型的加入。

List<T>则可以指定盛放的数据的类型。

 

 

编写泛型类：

class MyList<T>
    {
        private ArrayList list = new ArrayList();

        public T this[int index]
        {
            get
            {
                return (T)list[index];
            }

            set
            {
                list[index] = value;
            }
        }

        public void Add(T item)
        {
            list.Add(item);
        }

        public int Count
        {
            get
            {
                return list.Count;
            }
        }
    }

 

 class MyDictionary<K, V>
    {
        private Hashtable data = new Hashtable();

        public V this[K key]
        {
            get
            {
                return (V)data[key];
            }
            set
            {
                data[key] = value;
            }
        }

        public void Add(K key, V value)
        {
            data.Add(key, value);
        }

        public ICollection<K> Keys
        {
            get
            {
                List<K> list = new List<K>();
                foreach (object obj in data.Keys)
                {
                    list.Add((K)obj);
                }
                return list;
            }
        }
    }

 

•泛型方法：方法也可以定义泛型，在方法名后用<>将类型标注即可

 static IList<T> ToList<T>(ArrayList list)

        {

            IList<T> retList = new List<T>();

            foreach (object obj in list)

            {

                retList.Add((T)obj);

            }

            return retList;

        }定义成扩展方法

•(dropped).net内置的两个常用的类型转换的泛型方法，

所有实现了IEnumerable接口的对象都可以调用：Cast<T>将源序列转换为指定类型的范型序列；

OfType<T>将序列中类型为T的数据挑出来，结果以T类型序列返回。

 

将非泛型的数据转换为泛型的Cast或ofType方法：

static void Main(string[] args)
        {
            ArrayList list = new ArrayList();
            list.Add(1);
            list.Add(2);
            list.Add(8);

            var e1 = list.Cast<int>();
            
            //Hello2<int,string>(

            Console.ReadKey();
        }

 泛型委托：

.Net框架为我们提供了一些常用的委托，Func<>()、........等；

class Program
    {
        static void Main(string[] args)
        {
            My1Delegate m1 = H1;

            My2Delegate<string, int> m2 = H1;

           // m1 = H2;
            My2Delegate<bool, int> m3 = H2;

            //Fuckway
            Func<int> f1 = H3;
            Func<string> f2 = H4;

            //Func<int,string,bool>
        }

        static int H3()
        {
            return 0;
        }

        static string H4()
        {
            return "";
        }

        static void H1(string s1, int i2)
        {
        }

        static void H2(bool b, int i)
        {
        }
    }

    delegate void My1Delegate(string s1,int i2);

    delegate void My2Delegate<T1,T2>(T1 t1,T2 i2);

 泛型约束：

   class Program
    {
        static void Main(string[] args)
        {
            //Person p1 = new Person();
            CreateList<Dog>(3);
            //CreateList<Person>(5);
        }

        //where T:new()约束T必须有无参的构造函数
        //约束对于泛型委托、泛型类都是一样的
        static List<T> CreateList<T>(int n) where T:new()
        {
            List<T> list = new List<T>();
            for (int i = 0; i < n; i++)
            {
                //因为类可能没有无参的构造函数，所以不能保证一定成功
                //进行约束后，通过编译
                T p = new T();
                list.Add(p);
            }
            return list;
        }
    }

    class Person
    {
        public Person(int age)
        {
            this.Age = age;
        }
        public int Age { get; set; }
    }

    class Dog
    {
        //public Person(int age)
        //{
        //    this.Age = age;
        //}
        public int Age { get; set; }
    }

泛型约束之继承：

 class Program
    {
        static void Main(string[] args)
        {
           // PersonList<int> list1 = new PersonList<int>();//不行
            PersonList<Chinese> listc = new PersonList<Chinese>();//OK
        }
    }

    class PersonList<T> where T:Person //约束了T必须继承自Person
    {
        public void DotIt(T p1)
        {
            //p1.Name //因为约定了T必须继承自Person，所以可以在类内部调用Person的成员
        }
    }

    class Person
    {
        public string Name { get; set; }
    }

    class Chinese : Person
    {
        public string HuKou { get; set; }
    }

    class Dog
    {
    }

泛型约束的应用，用户自定义控件的事件中：

public partial class UserControl1 : UserControl
    {
        public UserControl1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            if (OnSanQiang != null)
            {
                Point p1 = new Point();//...
                SanQiangArgs args = new SanQiangArgs();
                args.CurPoint = p1;
                OnSanQiang(this, args);
            }
        }

        //public event SanQiangDelegate OnSanQiang;
        public event EventHandler<SanQiangArgs> OnSanQiang;
    }

    public delegate void SanQiangDelegate(object sender,Point p);

    public class SanQiangArgs : EventArgs//待定类型必须继承自EventArgs
    {
        public Point CurPoint{get;set;}
    }

 

//定义自己的可空类型
    class Program
    {
        static void Main(string[] args)
        {
            //int? i1 = 0;
            //i1.

            //int?编译器会翻译成Nullable<int>类型

            MyNullable<int> i1 = new MyNullable<int>();
            i1.HasValue = true;
            i1.Value = 3;
        }
    }

    class MyNullable<T> where T : struct
    {
        public bool HasValue { get; set; }
        public T Value { get; set; }
    }

 

409号