C#自定义泛型总结

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

namespace _03泛型约束
{

    class Student
    {

    }
    class Program
    {
        static void Main(string[] args)
        {
            Person<Student, int, Car, Car, int, Student> p1 = new Person<Student, int, Car, Car, int, Student>();
            // p1.Age = "豆蔻";

        }
    }
    //where T1 : struct ,表示约束了类型T1必须是[值类型]
    public class Person<T, T1, TC, TK, TV, TU>
        where T1 : struct //约束T1必须是值类型
        where T : class, new()//约束T必须是引用类型
        where TC : new()  //这个类型必须带有一个无参数的构造函数【要求：1.构造函数不能为私有，2.类型不能是抽象的。】
        where TK : Car //这里约束了TK类型，必须是Car类型或者是Car类型的子类
        where TV : IComparable //约束类TV必须是实现IComparable接口的类型。
        where TU : T  //约束了TU必须是T的子类。或者是T类型。
    {

        public T Name
        {
            get;
            set;
        }
        public T1 Age
        {
            get;
            set;
        }
        public T Email
        {
            get;
            set;
        }

        public TC MyCar
        {
            get;
            set;
        }

    }
    public class Car
    {
        public Car()
        {
            this.Brand = "捷安特";
        }
        public Car(string brand)
        {
            this.Brand = brand;
        }
        public string Brand
        {
            get;
            set;
        }
    }
}

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

namespace _01自定义泛型
{
    class Program
    {
        static void Main(string[] args)
        {
            //Type Parameters
            //T：   其实就是一个占位符，将来用对应的类型来代替。
            //TKey,TValue,TOutput,TReuslt
            //  List<int> list = new List<int>();
            //List<
            //list.Add(
            //Dictionary<


            //MyList ml = new MyList();
            //Console.WriteLine(ml[4]);
            ////MyListString mls = new MyListString();
            ////mls[0] = "yzk";
            ////mls[1] = "sk";

            MyListGeneric<int> mlg = new MyListGeneric<int>(100);
            mlg[0] = 10;
            mlg[1] = 101;
            mlg[2] = 102;
            Console.WriteLine(mlg[2]);

            Console.WriteLine("=============================");
            MyListGeneric<string> mlgString = new MyListGeneric<string>(100);

            mlgString[0] = "yzk";
            mlgString[1] = "sk";
            mlgString[2] = "jk";
            Console.WriteLine(mlgString[1]);


            Console.WriteLine("=========================");
            Person p1 = new Person() { Name = "yp", Age = 100 };
            Person p2 = new Person() { Name = "hf", Age = 109 };
            MyListGeneric<Person> mlgPerson = new MyListGeneric<Person>(100);
            mlgPerson[0] = p1;
            mlgPerson[1] = p2;
            Console.WriteLine(mlgPerson[1].Name);
            Console.ReadKey();
        }
    }

    public class Person
    {
        public string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public string Email
        {
            get;
            set;
        }

    }

    class MyList
    {
        int[] arrInt = new int[] { 10, 20, 30, 40, 50, 60, 70 };

        public int this[int index]
        {
            get
            {
                return arrInt[index];
            }
            set
            {
                arrInt[index] = value;
            }
        }
    }

    class MyListString
    {
        string[] arrInt = new string[100];

        public string this[int index]
        {
            get
            {
                return arrInt[index];
            }
            set
            {
                arrInt[index] = value;
            }
        }
    }

    //泛型的目的也是为了代码重用（算法重用）
    //class MyListGeneric<T,K,V,TOut,T1>
    class MyListGeneric<T>
    {

        public MyListGeneric(int len)
        {
            arr = new T[len];
        }
        //代码结构，算法一模一样，只是数据类型变了。
        // T[] arr = new T[100];
        private T[] arr;

        public T this[int index]
        {
            get
            {
                return arr[index];
            }
            set
            {
                arr[index] = value;
            }
        }

        public void SayHi(T t)
        {
            Console.WriteLine(t);
        }
    }
}

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

namespace _02泛型接口
{
    class Program
    {
        static void Main(string[] args)
        {
            MyClass1<string> mc1 = new MyClass1<string>();
            //mc1.M1
            Person p = new Person();
            //泛型方法，类本身不是泛型的，只有调用该方法的时候需要指定一下。
            p.SayHi<string>("hi!!!!");
            Console.ReadKey();
        }
    }

    public interface ITest<T>
    {
        void M1(T t);

        T M2();

        void M3(T obj);

        T PValue
        {
            get;
            set;
        }
    }

    //实现接口时候的两种方式。

    //“封闭类型”
    class MyClass : ITest<string>
    {

        #region ITest<string> 成员

        public void M1(string t)
        {
            throw new NotImplementedException();
        }

        public string M2()
        {
            throw new NotImplementedException();
        }

        public void M3(string obj)
        {
            throw new NotImplementedException();
        }

        public string PValue
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        #endregion
    }

    //“开放类型”
    class MyClass1<T> : ITest<T>
    {

        #region ITest<T> 成员

        public void M1(T t)
        {
            throw new NotImplementedException();
        }

        public T M2()
        {
            throw new NotImplementedException();
        }

        public void M3(T obj)
        {
            throw new NotImplementedException();
        }

        public T PValue
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        #endregion
    }



    //=====================泛型方法=====================

    public class Person
    {
        public string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public string Email
        {
            get;
            set;
        }
        //泛型方法
        public void SayHi<T>(T msg)
        {
            Console.WriteLine(msg);
        }

    }
}