C#泛型与多态示例

    // 泛型类； class引用类型约束;new()无参约束;struct值类型约束
    class TC1<T> where T : class
    {
        T member;

        #region 多态是指同一个行为具有多个不同表现形式或形态的能力；返回类型可以不一样，参数类型可以不一样，参数个数可以不一样。
        public int Add(int a, int b)
        {

            return a + b;
        }

        public int Add(int a, int b, string SS)
        {
            Console.WriteLine(SS);
            return a + b;
        }

        public int Add(string a, string b)
        {
            return Convert.ToInt32(a) + Convert.ToInt32(b);
        }

        public string Add(int a, String b)
        {
            int bi = Convert.ToInt32(b);
            return (a + b).ToString();
        }

        // 其他多态形式：接口、重写；
        #endregion 多态

        public TC1()  // 泛型演示
        {
            T dd = default;

            int aa = Fun1<int>(3);
            double aa1 = Fun1<double>(4);

            Console.WriteLine("T泛型" + aa + ";" + aa1);
            List<SS> c2s = Fun1s<SS>("输出C2");
            List<int> c2aa = Fun1s<int>("输出int");

            int ss = Str2IntFun<int, string>("1");
            Dictionary<int, string> keyValuePair = AddDict(2, "Value=2");
            keyValuePair.Add(3, "Value=3");

            StringBuilder stringBuilder = new StringBuilder();
            foreach (int key in keyValuePair.Keys)
            {
                stringBuilder.AppendLine(key + "," + keyValuePair[key]);
            }
            Console.WriteLine("多个泛型变量" + ss + ";" + stringBuilder.ToString());


        }

        /// <summary>
        /// 一般写法
        /// </summary>
        /// <typeparam name="T">值类型</typeparam>
        /// <param name="a"></param>
        /// <returns></returns>
        public T Fun1<T>(int a) where T : struct
        {
            T value = default;
            value = (T)Convert.ChangeType(a, typeof(T));

            return value;
        }

        /// <summary>
        /// 常用的写法
        /// </summary>
        public List<T> Fun1s<T>(string str)
        {
            List<T> values = new List<T>();
            Console.WriteLine(str);

            return values;
        }

        /// <summary>
        /// 多泛型值写法
        /// </summary>
        /// <typeparam name="TOne">值类型</typeparam>
        /// <typeparam name="TTwo">TTwo</typeparam>
        /// <param name="str"></param>
        /// <returns></returns>
        public TOne Str2IntFun<TOne, TTwo>(TTwo str) where TOne : struct where TTwo : class
        {
            TOne value = default;
            value = (TOne)Convert.ChangeType(str, typeof(TOne));
            return value;
        }

        /// <summary>
        /// 多泛型值写法_返回字典类型
        /// </summary>
        /// <typeparam name="TOne">值类型</typeparam>
        /// <typeparam name="TTwo">引用类型</typeparam>
        /// <param name="key">字典的key</param>
        /// <param name="value"></param>
        /// <returns></returns>
        public Dictionary<TOne, TTwo> AddDict<TOne, TTwo>(TOne key, TTwo value) where TOne : struct where TTwo : class
        {
            Dictionary<TOne, TTwo> dictionary1 = new Dictionary<TOne, TTwo>();
            dictionary1.Add(key, value);
            return dictionary1;
        }
    }
    class SS
    {

    }