泛型五大约束

最新推荐文章于 2024-04-28 20:19:05 发布
最新推荐文章于 2024-04-28 20:19:05 发布
阅读量4.9k 收藏 1
点赞数
分类专栏： C#从基础到高级
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_34201823/article/details/52438594
版权


//泛型类型约束//
using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;
using  System.Threading.Tasks;
namespace  泛型的类型约束
{
     class  Program
    {
         static  void  Main( string [] args)
        {
             //int a = 3, b = 20;
             //A<int> ah = new A<int>();
             //Console.WriteLine(ah.P(a, b));
             //int a = 10;
             C  c =  new  C ();
             B < C > bh =  new  B < C >();
            bh.P(c);
             //Console.WriteLine(b);
        }
    }
     public  interface  IM
    {
         int  Change();
         string  Compare();
    }
     //public class A<T>where T :IComparable
     //{
     //    public  T P(T a, T b)
     //    {
     //        if (a.CompareTo(b)>0)
     //        {
     //            return a;
     //        }
     //        else
     //        {
     //            return b;
     //        }
     //    }
     //}
     public  class  C : IM
    {
         public    int  Change()
        {
             Console .WriteLine( "这是接口IM的Change方法" );
             return  0;
        }
         public    string  Compare()
        {
             Console .WriteLine( "这是接口IM的Compare方法" );
             return  null ;
        }
    }
     public  class  B  < T > where  T  : IM
    {        
         public  T  P( T  a)
        {
             if  (a.Change() > 0)
            {
                 return  a;
            }
             return  a;
        }
}
   
}


//泛型五大类型约束
using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;
using  System.Threading.Tasks;
namespace  泛型的五大约束
{
     泛型类的五大约束
     // 1. where T：struct  限定当前参数类型必须是值类型
     // 2. where T：class   限定当前类型参数类型必须是引用类型
     // 3. where T：new（） 限定当前参数类型必须有一个无参构造器
     // 4. where T：<base class name>   限定当前参数类型 必须是当前类  或者当前类为基类的类
     //父类名
     // 5. where T：<interface name>限定当前参数类型必须实现指定接口 
     class  Program
    {
         static  void  Main( string [] args)
        {
             //D<Base> d = new D<Base>();
             //Base ba = new Base();
             //Console.WriteLine("泛型类D的  funcd的方法  在此被调用");
             //d.funcd(ba);//此处调用funcd的方法
             //C<Cb> c = new C<Cb>();
             //c.f();
             F  f =  new  F ();
             E < F > e =  new  E < F >();
            e.funce(f);
        }
    }
     public  class  Base
    {
         public  void  fb()
        {
             Console .WriteLine( "这是基类Base的方法fb" );
        }
    }
     public  class  A < T > where  T : struct
    {
         public  void  funca( T  a)
        {
        }
    }
     public  class  B
    {
    }
     public  class  C < T >  where  T  : new ()
    {
         public  void  f()
        {
             Console .WriteLine( "这里是无参构造函数的方法" );
        }
    }
     public  class  Cb
    {
         public  Cb()
        {
        }
      
    }
     public  class  D < T > where  T  : Base
    {
         public  void  funcd( T  a)
        {
            a.fb();
        }
    }
     public  interface  INter
    {
         int  funinter();
    }
     public  class  F : INter
    {
         public    int  funinter()
        {
             Console .WriteLine( "这里是实现了继承接口内的方法" );
             return  0;
        }
    }
     public  class  E < T >  where  T : INter // 第五种类型
    {
         public  T  funce( T  a)
        {
            a.funinter();
             Console .WriteLine( "这里是E内的方法的实现" );
             return  a;
         
        }
    }
   
}
//泛型类型约束//
using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;
using  System.Threading.Tasks;
namespace  泛型的类型约束
{
     class  Program
    {
         static  void  Main( string [] args)
        {
             //int a = 3, b = 20;
             //A<int> ah = new A<int>();
             //Console.WriteLine(ah.P(a, b));
             //int a = 10;
             C  c =  new  C ();
             B < C > bh =  new  B < C >();
            bh.P(c);
             //Console.WriteLine(b);
        }
    }
     public  interface  IM
    {
         int  Change();
         string  Compare();
    }
     //public class A<T>where T :IComparable
     //{
     //    public  T P(T a, T b)
     //    {
     //        if (a.CompareTo(b)>0)
     //        {
     //            return a;
     //        }
     //        else
     //        {
     //            return b;
     //        }
     //    }
     //}
     public  class  C : IM
    {
         public    int  Change()
        {
             Console .WriteLine( "这是接口IM的Change方法" );
             return  0;
        }
         public    string  Compare()
        {
             Console .WriteLine( "这是接口IM的Compare方法" );
             return  null ;
        }
    }
     public  class  B  < T > where  T  : IM
    {        
         public  T  P( T  a)
        {
             if  (a.Change() > 0)
            {
                 return  a;
            }
             return  a;
        }
}
   
}


//泛型五大类型约束
using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;
using  System.Threading.Tasks;
namespace  泛型的五大约束
{
     泛型类的五大约束
     // 1. where T：struct  限定当前参数类型必须是值类型
     // 2. where T：class   限定当前类型参数类型必须是引用类型
     // 3. where T：new（） 限定当前参数类型必须有一个无参构造器
     // 4. where T：<base class name>   限定当前参数类型 必须是当前类  或者当前类为基类的类
     //父类名
     // 5. where T：<interface name>限定当前参数类型必须实现指定接口 
     class  Program
    {
         static  void  Main( string [] args)
        {
             //D<Base> d = new D<Base>();
             //Base ba = new Base();
             //Console.WriteLine("泛型类D的  funcd的方法  在此被调用");
             //d.funcd(ba);//此处调用funcd的方法
             //C<Cb> c = new C<Cb>();
             //c.f();
             F  f =  new  F ();
             E < F > e =  new  E < F >();
            e.funce(f);
        }
    }
     public  class  Base
    {
         public  void  fb()
        {
             Console .WriteLine( "这是基类Base的方法fb" );
        }
    }
     public  class  A < T > where  T : struct
    {
         public  void  funca( T  a)
        {
        }
    }
     public  class  B
    {
    }
     public  class  C < T >  where  T  : new ()
    {
         public  void  f()
        {
             Console .WriteLine( "这里是无参构造函数的方法" );
        }
    }
     public  class  Cb
    {
         public  Cb()
        {
        }
      
    }
     public  class  D < T > where  T  : Base
    {
         public  void  funcd( T  a)
        {
            a.fb();
        }
    }
     public  interface  INter
    {
         int  funinter();
    }
     public  class  F : INter
    {
         public    int  funinter()
        {
             Console .WriteLine( "这里是实现了继承接口内的方法" );
             return  0;
        }
    }
     public  class  E < T >  where  T : INter // 第五种类型
    {
         public  T  funce( T  a)
        {
            a.funinter();
             Console .WriteLine( "这里是E内的方法的实现" );
             return  a;
         
        }
    }
   
}
zhuang__ming
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#的泛型方法解析
09-01
泛型是C#编程语言中的一个核心特性，它在C#2.0版本中被引入，极大地提高了代码的灵活性和效率。泛型允许我们在编写代码时推迟类型决定，直到实际运行时，这样既能保证类型安全，又能实现高效的代码重用。 ### 一、...
详细介绍C# 泛型
08-18
C#泛型的引入始于.NET Framework 2.0，它极大地提高了代码的灵活性和性能。 ### 一、泛型的主要优势 1. **性能更高**：泛型避免了值类型到引用类型的装箱和拆箱操作，这在处理大量数据时能显著提高程序的运行效率...
C#泛型约束
qq_60069700的博客
05-24 6089
泛型的六种约束
【笔记】C# 泛型约束
好学若饥，谦卑若愚。
03-26 2768
🗽 泛型约束就是告知编译器类型参数必须具备的功能。在没有任何约束的情况下，类型参数可以是任何类型。编译器只能假定 System.Object 的成员，它是任何 .NET 类型的最终基类。当分配给泛型的类型参数不满足约束的类型时，编译器会报出 Compiler Error CS0452 的错误。在 C# 中允许使用 where 上下文关键字指定约束。表示为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数。
C# 中泛型编程之泛型类、泛型方法、泛型约束详解
最新发布
u011555996的博客
04-28 1344
类型Type现在可以表示带有特定类型的实参(或绑定类型)或未指定类型的泛型(或称未绑定类型)。委托级别的约束只在声明委托变量和实例化委托时使用，类似于在类型和方法的作用范围中实施的其他任何约束。同时子类中的泛型方法不能重复基类泛型方法的约束，这一点和泛型类中的虚方法重写是有区别的，代码如下。////错误 重写和显式接口实现方法的约束是从基方法继承的，因此不能直接指定这些约束。类型参数必须具有无参数的公共构造函数。3.在子类重复基类的约束(在使用子类泛型参数时,必须在子类级别重复在基类级别规定的任何约束)
什么是泛型约束？
dxn16638400024的博客
09-24 366
泛型约束的作用是提供更精确的类型控制和更强的类型安全性。通过约束泛型类型参数，我们可以在编译时捕获错误，并防止不合适的类型被传递给泛型代码。这样，泛型类型参数就会被限制为必须是指定类型或其子类型。在使用泛型方法时，我们传递了一个整数数组和一个字符串数组作为参数，并分别获取了最大的整数和最大的字符串。通过使用泛型约束，我们可以确保只有符合特定条件的类型才能被传递给泛型代码，从而提高代码的可靠性和安全性。接口的类型数组，并返回数组中最大的元素。使用泛型约束的语法是在泛型类型参数后面使用。必须是可比较的类型。
C#面：泛型有哪些常见约束
那个那个鱼的博客
04-24 610
C# 泛型提供了一种在编译时对类型进行参数化的方式，可以增加代码的灵活性和重用性。在使用泛型时，可以对泛型参数进行约束，以限制可以传递给泛型类型或方法的类型。这些约束可以单独使用，也可以组合使用，以满足特定的需求。通过使用泛型约束，可以在编译时对泛型类型或方法的参数类型进行限制，提高代码的类型安全性和可读性。
泛型的约束不止一面
m0_56069948的博客
09-17 892
泛型中的约束，其实就是针对类型参数的约束，限制类型参数的选择只能在某个特定范围内。其中的体现包括：限制类型参数必须是一个结构、限制类型参数必须是某个具体类型、限制类型参数必须派生自某个基类等等。在默认情况下，定义的泛型没有任何约束，这意味着在调用泛型时，可以使用任何数据类型作为类型参数。如果定义了约束，则在应用端调用泛型时，不传入符合约束条件的类型参数，编译器将提示错误。通过这种约束实现了编译前类型检查，确保了泛型在运行时对类型参数使用的安全性。
第十五课 泛型基础1
08-03
总的来说，泛型是TypeScript中一个非常重要的概念，它极大地提高了代码的灵活性和可维护性，同时保持了类型安全性。在前端开发中，熟练掌握和运用泛型可以提升代码质量，降低维护成本，是成为专业前端开发者不可或缺...
前端大厂最新面试题-generic.docx
06-06
* 类型约束：泛型可以用来实现类型约束，例如限制类型参数的范围。 五、结论 泛型编程是 TypeScript 中的一种强大且灵活的编程技术，可以帮助我们编写更加灵活、可重用和类型安全的代码。通过本文，我们应该已经...
Java基础知识总结
10-13
六至十四的内容未给出，但通常涵盖的话题可能包括线程同步、常用类如`System`和`Date`，枚举类的使用，注解的声明和应用，集合的高级用法如`List`和`Set`的遍历，泛型的类型约束和类型推断，IO流的读写操作，网络...
泛型约束，.NET 中越来越多的使用到泛型
09-12
泛型，无论在Java中还是在C#中，应用都很广泛，可以解决很多关于类型的问题
泛型的四种约束
imJaron的博客
01-27 1714
对于泛型类型或者泛型方法，可以对类型指定约束。约束放在类型声明的末尾，然后用where来引入。 1. 引用类型约束： (T : class)， 即T必须是一个引用类型。 struct Test where T : class
泛型约束
NCTU_to_prove_safety的博客
07-10 411
要T是继承于Awhere T: A要T继承于B的where T: B在定义泛型类时，可以对客户端代码能够在实例化类时用于类型参数的类型种类施加限制。如果客户端代码尝试使用某个约束所不允许的类型来实例化类，则会产生编译时错误。这些限制称为约束。约束是使用 where 上下文关键字指定的。下表列出了六种类型的约束：约束 说明T：结构 类型参数必须是值类型。可以指定除 Nullable 以外的任何值类型...
C#泛型与泛型约束
Codeeror的博客
01-24 3105
为什么要使用泛型 考虑一种堆栈类 class Stack { public string[] Elements { get; set; } public int Current { get; set; } public string Pop() { return Elements[Current]; ...
C#五大泛型约束
qq_43893500的博客
04-28 6036
C#六大泛型约束基类约束接口约束new()构造函数约束引用/值类型约束组合约束 基类约束 基类约束有两个功能，首先，它允许泛型类使用基类约束所定义的的成员，第二个功能是确保泛型类使用指定基类的类型实参，这意味着，在使用泛型类时，类型实参必须是基类本身或者是派生自该基类的类。 class Program { static void Main(string[] args) ...
泛型(7)——泛型的约束
qq_34573534的博客
09-07 220
1、约束父类或者接口：AAA<T> where T:IDbConnection 2、约束构造函数： AAA <T> where T:new()， AAA <T> where T:new()。 3、where T:new()约束T必须有无参的构造函数。 4、约束对于泛型委托、泛型类都是一样的。 5、泛型创建一个返回N个对象的方法。 6、泛型创建一个对...
泛型约束使用？有些不知道叫什么好！
weixin_34144450的博客
07-03 815
代码usingSystem;usingSystem.Collections.Generic;usingSystem.Text;usingSystem.Threading;usingSystem.Data;//----------usingCommon;usingdataAccess;usingprovider;usingmodle;namespaceCommon{pub...
泛型的约束范围（编译期）
silentpauljian的专栏
03-22 376
<br />一个用泛型定义的Map<String,String>，总是报错：Integer不能转为字符串。 <br />我就纳闷了，怎么可能是Integer，我什么时候用了Integer了？后来打开map里面的 <br />Entry才发现，真是Integer。泛型的约束只在编译器起作用，到了运行期里面爱塞什么<br />东西谁也管不了了呀。<br />之前这个map是用jsonlib把json还原得到的。可能在里面，看到值没有引号，<br />于是jsonlib就自作聪明地变成了Integer。
typescript 泛型约束
06-09
TypeScript 泛型约束可以帮助我们限制泛型参数的类型范围，确保代码的类型安全性。以下是一个例子： ```typescript interface Lengthwise { length: number; } function loggingIdentity(arg: T): T { console....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值