#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;

      }

    }