C# 泛型

迈不过友情╰ 2022-06-06 03:44 284阅读 0赞

**一.泛型类**  
1.基类约束

/// <summary>
        /// 基类约束，约束成了T必须传入Pig本身或者其子类
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public class PigHouse<T> where T :Pig
        {
            /// <summary>
            /// 泛型类在泛型方法里面,使用的占位符是泛型类中的类型占位符，则可以不写
            /// </summary>
            /// <returns></returns>
            public T GetT()
            {
                return default(T);
            }
            /// <summary>
            /// 泛型方法使用的类型占位符是泛型类中的类型占位符之外的，则必须使用<K>来指定，否则报错
            /// </summary>
            /// <typeparam name="K"></typeparam>
            /// <returns></returns>
            public K Get<K>()
            {
                return default(K);
            }
        }

2.接口约束

/// <summary>
        /// 接口约束
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public class House1<T> where T : IPig
        {
    
        }
    
        public interface IPig
        {
        }

3.引用类型约束

/// <summary>
        /// 引用类型约束
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public class House2<T> where T : class
        {
        }

4.值类型约束

/// <summary>
        /// 值类型约束
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public class House3<T> where T : struct
        {
        }

5.构造器约束

/// <summary>
        /// 构造器约束
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public class House4<T> where T :new()
        {
            T t;
            public House4()
            {
                //由于在此处要new T()所以必须在类后面添加构造器约束，
                t = new T();
            }
            public T Instance
            {
                get
                {
                    return t;
                }
            }
        }

**二.泛型类方法**

/* 泛型方法： 1.泛型方法既可以定义在普通类中也可以定义在泛型类中 2.泛型方法构成重载的条件： a.方法参数格式不同 b.方法参数类型不同 c.方法的类型占位符的个数不同 注意类型占位符格式相同但是名称不同不够成重载 */
        public class 泛型方法
        {
            /// <summary>
            /// 泛型方法的类型占位符只在方法的方法体，返回类型，参数中有效
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="t"></param>
            /// <returns></returns>
            public T GetT<T>(T t)
            {
                return t;
            }
            /// <summary>
            /// 返回类型的默认值，如果是int返回0，如果是string返回null。。。。
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <returns></returns>
            public T GetT1<T>()
            {
                return default(T);
            }
            /// <summary>
            /// 泛型重载
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="t"></param>
            /// <returns></returns>
            public T GetT1<T>(T t)
            {
                return t;
            }
            public T GetT1<T,V>(int t)
            {
                return default(T);
            }
            public string Get()
            {
    
                return "";
            }
        }

**三.泛型方法的重写**

public abstract class AbstractClass
        {
            //泛型方法添加约束
            public abstract T SayHi<T, U>(T t, U u) where U : T;//U必须继承T
        }
        public class SubCls1 : AbstractClass
        {
            public override T SayHi<T, U>(T t, U u)//不需要在子类中重写泛型方法的时候不需要再添加类型占位符的约束，此约束已经在父类继承
            {
                throw new Exception("");
            }
        }

**四.泛型类的继承**

public class BaseClass<K, V> 
            where K : class
            where V : struct
        {
        }
        /// <summary>
        /// 如果 是普通类继承泛型类，则应该确定好泛型类中的各个类型占位符的具体类型
        /// </summary>
        public class SubClass1 : BaseClass<Pig, int>
        {
    
        }
        /// <summary>
        /// 泛型类继承泛型类，可以制定具体的类型
        /// </summary>
        /// <typeparam name="X"></typeparam>
        /// <typeparam name="Y"></typeparam>
        public class SubClass2<X,Y> : BaseClass<Pig, int>
        {
    
        }
        /// <summary>
        /// 常用的继承方式,可以将泛型类的类型占位符传递给父类
        /// </summary>
        /// <typeparam name="X"></typeparam>
        /// <typeparam name="Y"></typeparam>
        public class SubClass3<X, Y> : BaseClass<X, Y>
              where X : class
            where Y : struct
        {
    
        }

**五.泛型缓存**

using System.Web;
        /// <summary>
        /// 利用泛型方法将原来的缓存管理类中的获取数据方法优化
        /// </summary>
        public class CacheMg
        {
            public static void Add(string cacheKey, object obj)
            {
                HttpRuntime.Cache[cacheKey] = obj;
            }
            public static T GetData<T>(string cacheKey)
            {
                return (T)HttpRuntime.Cache[cacheKey];
            }
        }
        public class CallCache
        {
            public CallCache()
            {
                Pig pig = new Pig();
                CacheMg.Add("Key", pig);
    
                //从缓存中根据key获取值
                // Pig p = CacheMg.GetData("Key") as Pig;
                Pig p = CacheMg.GetData<Pig>("Key");
            }
        }