泛型约束

代码

         ///   <summary>
         ///  默认构造函数约束
         ///   </summary>
         ///   <typeparam name="U"></typeparam>
         public   class  GetEntity < U >   where  U :  new ()
        {
            U u  =   new  U();
        }
         /* ---------派生约束---------- */
         /*
         * 如果希望在泛型内部使用类型参数实例的某些方法，就必须使用派生约束
          */
         public   interface  ICommon
        {
             void  Add( object  obj);
             void  Update( object  obj);
           

        }
         public   class  Common: ICommon
        {
             public   virtual   void  Add( object  obj)
            {

            }
             public   virtual   void  Update( object  obj)
            {

            }

        }
         public   class  UserDao:Common 
        {
             public   override   void  Add( object  obj)
            {
                Console.WriteLine( " 插入一条User记录 " );
            }
             public   override   void  Update( object  obj)
            {
                Console.WriteLine( " 更新一条User记录 " );
            }
        }
         public   class  Base
        {
             public   virtual   void  Open()
            {

            }
             public   virtual   void  Close()
            {

            }
        }
         ///   <summary>
         ///  只派生接口约束
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         public   class  Operate1 < T >   where  T : ICommon, new  ()
        {
           
             public   void  Add( object  obj)
            {   
                T t  =   new  T();
                Console.WriteLine( " Add: " );
                t.Add(obj);
            }
             public   void  Update( object  obj)
            {
                T t  =   new  T();
                Console.WriteLine( " Update: " );
                t.Update(obj);
                
            }
        }
         ///   <summary>
         ///  派生类和接口：
         ///  可以在一个类型参数上添加多个接口实现约束和一个基类继承约束。
         ///  这种约束可以和默认构造函数约束同时使用，这时默认构造函数约束必须出现在列表尾部。
         ///  不能使用类型参数T的静态成员
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         public   class  Operate2 < T >  :Base  where  T :ICommon,  new ()
        {

             public   void  Add( object  obj)
            {
                Base b  =   new  Base();
                T t  =   new  T();
                b.Open();
                Console.WriteLine( " Add: " );
                t.Add(obj);
                b.Close();

            }
             public   void  Update( object  obj)
            {
                T t  =   new  T();
                Console.WriteLine( " Update: " );
                t.Update(obj);

            }
            
            

        }
调用实现
        public   static   void  FanxingYueShu()
        {
            Operate1 < Common >  common  =   new  Operate1 < Common > ();
            User user = new  User ();
            user.Id = 1 ;
            user.UserName = " carl " ;
            user.UserPwd  =   " carl " ;
            common.Add(user);
            common.Update(user);
            Operate2 < Common >  common2  =   new  Operate2 < Common > ();
            common2.Add( new   object ());
            common2.Update( new   object ());
        }

 

转载于:https://www.cnblogs.com/hubcarl/archive/2010/04/07/1706359.html