C#-泛型

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using TestMyGeneric;

//泛型类
public class MyGeneric<T> : IMyGeneric<string>
{
    public T _T;

    public string GetT(string t)
    {
        return t;
    }
}

//子类继承泛型父类，必须指定具体类型，如果子类也是泛型，则不用指定
public class MyGenericSubClass : MyGeneric<int>
{

}

//泛型接口
public interface IMyGeneric<T>
{
    T GetT(T t);
}

//泛型接口也是一样，必须指定具体类型，如果子类也是泛型，则不用指定
public interface IMyGenericSub : IMyGeneric<double>
{

}

//泛型委托
public delegate T OnPrint<T>(T t);

public struct StructDemo
{
    public int Id { get; set; }
    public string Name { get; set; }
}

namespace TestMyGeneric
{
    public interface ISports
    {
        void Pingpang();
    }

    public interface IWork
    {
        void Work();
    }

    public class People
    {
        public int Id { get; set; }
        public string Name { get; set; }

        public void Hi()
        {
           Debug.Log("Hi");
        }
    }

    public class Chinese : People, ISports, IWork
    {
        public void Tradition()
        {
             Debug.Log("good good good!!");
        }
        public void SayHi()
        {
             Debug.Log("nin chi le me？");
        }

        public void Pingpang()
        {
            Debug.Log("Play Pingpang...");
        }

        public void Work()
        {
            Debug.Log("Work Hard...");
        }
    }

    public class Hubei : Chinese
    {
        public Hubei(int version)
        { }

        public string Changjiang { get; set; }
        public void Majiang()
        {
            Debug.Log("Play Majiang...");
        }
    }

    public class Japanese : ISports
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public void Hi()
        {
             Debug.Log("Hi");
        }
        public void Pingpang()
        {
            Debug.Log("Play Pingpang...");
        }
    }
}

public class TestGeneric : MonoBehaviour
{

	// Use this for initialization
	void Start () {

        ShowMyData("lalala");
        ShowMyData(5);
        ShowMyData(6.66);

        MyGeneric<string> g1 = new MyGeneric<string>();
        g1._T = "hello";

        MyGeneric<int> g2 = new MyGeneric<int>();
        g2._T = 123;

        Debug.Log(g1.GetT(g1._T));
        Debug.Log(g2.GetT(g2._T.ToString()));

        MyGenericSubClass s1 = new MyGenericSubClass();
        s1._T = 456;
        Debug.Log(s1.GetT(s1._T.ToString()));

        TestFunc();

        //泛型代理
        OnPrint<string> myPrint = new OnPrint<string>(GetMyPrint);
        myPrint.Invoke("myPrint~~~");

        OnPrint<int> myPrintInt = new OnPrint<int>(GetMyPrint);
        myPrintInt.Invoke(5);

        OnMyPrint<string>(GetMyPrint, "111");
        OnMyPrint<int>(GetMyPrint, 222);
	}
	
    public void OnMyPrint<T>(OnPrint<T> t, T v)
    {
        t(v);
    }

    public T GetMyPrint<T>(T t)
    {
        Debug.Log(t);
        return t;
    }

    //泛型方法
    private void ShowMyData<T>(T t)
    {
        Debug.Log("type = " + t.GetType().ToString() + " value = " + t.ToString());
    }

    public void TestFunc()
    {
        People people = new People()
        {
            Id = 123,
            Name = "People"
        };
        Chinese chinese = new Chinese()
        {
            Id = 234,
            Name = "Chinese"
        };
        Hubei hubei = new Hubei(123)
        {
            Id = 345,
            Name = "Hubei"
        };
        Japanese japanese = new Japanese()
        {
            Id = 7654,
            Name = "Japanese"
        };

        ShowObject(people);
        ShowObject(chinese);
        ShowObject(hubei);
        //ShowObject(japanese);

        Show(chinese);

        var obj1 = GenericToDefault<string>();
        var obj2 = GenericToDefault<int>();
        var obj3 = GenericToDefault<StructDemo>();
    }

    /// <summary>
    /// 基类约束：约束T必须是People类型或者是People的子类
    /// 基类约束时，基类不能是密封类，即不能是sealed类。sealed类表示该类不能被继承，在这里用作约束就无任何意义，因为sealed类没有子类。
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="oParameter"></param>

    private void ShowObject<T>(T oParameter) where T : People
    {
        Debug.Log(oParameter.GetType().Name + " " + oParameter.Id + " " + oParameter.Name);
    }

    /// <summary>
    /// 接口约束
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="t"></param>
    /// <returns></returns>
    public T GetTSports<T>(T t) where T : ISports
    {   
        t.Pingpang();
        return t;
    }

    /// <summary>
    /// 引用类型约束
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="t"></param>
    /// <returns></returns>
    public T GetTClass<T>(T t) where T : class
    {
        return t;
    }

    /// <summary>
    /// 值类型类型约束
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="t"></param>
    /// <returns></returns>
    public T GetTStruct<T>(T t) where T : struct
    {
        return t;
    }

    /// <summary>
    /// 无参数构造函数约束  new()
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="t"></param>
    /// <returns></returns>
    public T GetTNew<T>(T t) where T : new()
    {
        return t;
    }

    //注意：有多个泛型约束时，new()约束一定是在最后。
    public void Show<T>(T tParameter) where T : People, ISports, IWork, new()
    {
        Debug.Log(tParameter.Id + tParameter.Name);
        tParameter.Hi();
        tParameter.Pingpang();
        tParameter.Work();
    }

    //给定参数化类型 T 的一个变量 t，只有当 T 为引用类型时，语句 t = null 才有效；
    //只有当 T 为数值类型而不是结构时，语句 t = 0 才能正常使用。
    //解决方案是使用 default 关键字，此关键字对于引用类型会返回空，对于数值类型会返回零。
    //对于结构，此关键字将返回初始化为零或空的每个结构成员，具体取决于这些结构是值类型还是引用类型。
    /// <summary>
    /// 泛型代码中的默认关键字：Default
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    public static T GenericToDefault<T>()
    {
        return default(T);
    }

	// Update is called once per frame
	void Update () {
		
	}
}