c# 泛型类型参数与约束的深入分析

private void PromptName<T>(T t) {}
private void PromptName<Tuser>(Tuser user){}

public class ShowObjectType<T> where T : struct
    {
        public void ShowValue<T>(T t)
        {
            Console.WriteLine(t.GetType());
        }
    }
    class GenericConstraint
    {
        static void Main()
        {

            ShowObjectType<int> showInt = new ShowObjectType<int>();
            showInt.ShowValue<int>(5);
            showInt.ShowValue(5);//从参数可以推导出类型参数类型，则可以省略类型参数类型

            //因为约束为值类型，下面代码不能通过编译
            ShowObjectType<string> showString = new ShowObjectType<string>();
            showString.ShowValue("5");
            Console.Read();
        }
    }

class GenericConstraint
    {
        static void Main()
        {
              List<string > list = new List<string>();
            AddClass<string>(list, "hello generic");
            Console.Read();
        }
        private static void AddClass<T>(List<T> list, T t) where T : class
        {
            list.Add(t);
        }
    }

class GenericConstraint
    {
        static void Main()
        {
            Person person = new Person { ID = 1, Name = "David" };
            PromptName<Person>(person);
            Console.Read();
        }
        //此约束T为Person对象或者继承Person对象
        private static void PromptName<T>(T t) where T : Person
        {
            //此处可使用Person的Name属性
            if (t.Name == "David")
            {
                Console.WriteLine("Person name is David");
            }
            string name = t.GetName();
            Console.WriteLine("Person name is {0}", name);
        }
    }
    public class Person
    {
        private int id;
        public int ID
        {
            get { return id; }
            set { id = value; }
        }
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public string GetName()
        {
            return Name;
        }
    }

class Base { }
class Test<T, U>
    where U : struct
    where T : Base, new() { }

class  List<T>{}