#region 泛型的约束
        
    /// <summary>
    /// 1.0基类约束
    /// </summary>
    /// <typeparam name="T">约束成了将来调用的时候只能传入Pig本身或者其子类</typeparam>
   public  class House<T> where T:Pig
    {

    }

    /// <summary>
    /// 2.0 引用类型约束
    /// </summary>
    /// <typeparam name="T">约束成了将来调用的时候只能传入引用类型参数</typeparam>
    public class House1<T> where T:class
    {

    }

    /// <summary>
    /// 3.0值类型约束
    /// </summary>
    /// <typeparam name="T">约束成了将来调用的时候只能传入值类型参数</typeparam>
    public class House2<T> where T:struct
    {

    }

    /// <summary>
    /// 4.0接口约束
    /// </summary>
    /// <typeparam name="T">约束成了将来调用的时候只能传入Ipig本身或者Ipig的实现类型参数</typeparam>
    public class House3<T>where T:IPig
    {

    }

    /// <summary>
    /// 5.0构造器约束
    /// </summary>
    /// <typeparam name="T">约束成了将来调用的时候只能传入 构造器参数</typeparam>
    public class House4<T>where T:class ,new()
    {
        T t;
        public House4()
        {
            t = new T();
        }
    }

    /// <summary>
    /// 多个参数约束
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="V"></typeparam>
    public class House6<T, V>
        where T : class
        where V : struct
    {

    }
 
    #endregion

    #region 泛型的继承
    public class DogHouse6 : House6<Dog, int>
    {

    }

    public class DogHouse61<X, Y> : House6<X, Y>
        where X : class
        where Y : struct
    {

    }

    public class DogHouse62<X, Y> : House6<Pig, decimal>
    {
        
    }
    
    #endregion

    #region 泛型方法
    /// <summary>
    /// 泛型方法  有下列任何一项  均构成重载：
    /// 1.泛型方法的参数个数不一致 
    /// 2.参数类型不一致
    /// 3.类型占位符个数不一致
    /// 
    /// 
    /// 泛型方法的类型占位符个数一致，但名字不一样 不会构成重载
    /// </summary>
    public class UserInfoBll
    {
        public T Get<T>(T t)
        {
            return t;
        }

        public string GetName<T>(T t, int num)
        {
            T tt = t;
            return "某一个参数类型为泛型，返回值为string";
        }

        public string GetName<T, V>(T t, int num)
        {
            T tt = t;
            return "返回值";
        }

        public T GetName<T>(string str)
        {
            return default(T);
        }

        public string GetName<T>(T t)
        {
            T tt = t;
            return "返回值";
        }
    }

    public class UserInfoBll1<T>
    {
        T tt;
        public T GetT(T t)
        {
            tt = t;
            return tt;
        }
    } 
    #endregion

    #region 泛型方法的重写
    public abstract class Father
    {
        public abstract T SayHi<T, U>(T t, U u) where U : T; // U必须继承于T

        public abstract T Think<T>(T t) where T : Pig;
    }

    /// <summary>
    /// 子类重写父类中的抽象泛型方法的时候，不需要单独再将类型占位符 重新添加约束
    /// </summary>
    public class Son : Father
    {
        public override T SayHi<T, U>(T t, U u)
        {
            return t;
        }

        public override T Think<T>(T t)
        {
            return default(T);
        }
    } 
    #endregion

  public   class CacheMgr<T>
    {
      public static T Get(string cacheKey)
      {
          return (T)HttpRuntime.Cache[cacheKey];
      }

      public static void Add<TT>(string cacheKey,TT value)
      {
          HttpRuntime.Cache[cacheKey] = value;
      }
    }