泛型类型编写

C#泛型机制与应用
最新推荐文章于 2022-08-16 16:57:54 发布
转载 最新推荐文章于 2022-08-16 16:57:54 发布 · 1.3k 阅读 · 2
文章标签：

#string #class #c# #编译器 #object #function

  泛型：通过参数化类型来实现在同一份代码上操作多种数据类型。利用“参数化类型”将类型抽象化，从而实现灵活的复用。

例子代码：

class Program

    {

        static void Main(string[] args)

        {

            int obj = 2;

            Test<int> test =new Test<int>(obj);

            Console.WriteLine("int:" + test.obj);

            string obj2 = "hello world";

            Test<string> test1 =new Test<string>(obj2);

            Console.WriteLine("String:" + test1.obj);

            Console.Read();

        }

    }

 

    class Test<T>

    {

        public T obj;

        public Test(T obj)

        {

            this.obj = obj;

        }

}

    输出结果是：

    int:2

String:hello world

 

程序分析：

1、  Test是一个泛型类。T是要实例化的范型类型。如果T被实例化为int型，那么成员变量obj就是int型的，如果T被实例化为string型，那么obj就是string类型的。

2、  根据不同的类型，上面的程序显示出不同的值。

 

C#泛型机制：

C#泛型能力有CLR在运行时支持：C#泛型代码在编译为IL代码和元数据时，采用特殊的占位符来表示范型类型，并用专有的IL指令支持泛型操作。而真正的泛型实例化工作以“on-demand”的方式，发生在JIT编译时。

 

看看刚才的代码中Main函数的元数据

.method private hidebysig static void  Main(string[] args) cil managed

{

  .entrypoint

  // Code size       79 (0x4f)

  .maxstack  2

  .locals init ([0] int32 obj,

           [1] class CSharpStudy1.Test`1<int32> test,

           [2] string obj2,

           [3] class CSharpStudy1.Test`1<string> test1)

  IL_0000:  nop

  IL_0001:  ldc.i4.2

  IL_0002:  stloc.0

  IL_0003:  ldloc.0

  IL_0004:  newobj     instance void class CSharpStudy1.Test`1<int32>::.ctor(!0)

  IL_0009:  stloc.1

  IL_000a:  ldstr      "int:"

  IL_000f:  ldloc.1

  IL_0010:  ldfld      !0 class CSharpStudy1.Test`1<int32>::obj

  IL_0015:  box        [mscorlib]System.Int32

  IL_001a:  call       string [mscorlib]System.String::Concat(object,

                                                              object)

  IL_001f:  call       void [mscorlib]System.Console::WriteLine(string)

  IL_0024:  nop

  IL_0025:  ldstr      "hello world"

  IL_002a:  stloc.2

  IL_002b:  ldloc.2

  IL_002c:  newobj     instance void class CSharpStudy1.Test`1<string>::.ctor(!0)

  IL_0031:  stloc.3

  IL_0032:  ldstr      "String:"

  IL_0037:  ldloc.3

  IL_0038:  ldfld      !0 class CSharpStudy1.Test`1<string>::obj

  IL_003d:  call       string [mscorlib]System.String::Concat(string,

                                                              string)

  IL_0042:  call       void [mscorlib]System.Console::WriteLine(string)

  IL_0047:  nop

  IL_0048:  call       int32 [mscorlib]System.Console::Read()

  IL_004d:  pop

  IL_004e:  ret

} // end of method Program::Main

 

    再来看看Test类中构造函数的元数据

.method public hidebysig specialname rtspecialname

        instance void  .ctor(!T obj) cil managed

{

  // Code size       17 (0x11)

  .maxstack  8

  IL_0000:  ldarg.0

  IL_0001:  call       instance void [mscorlib]System.Object::.ctor()

  IL_0006:  nop

  IL_0007:  nop

  IL_0008:  ldarg.0

  IL_0009:  ldarg.1

  IL_000a:  stfld      !0 class ConsoleCSharpTest1.Test`1<!T>::obj

  IL_000f:  nop

  IL_0010:  ret

} // end of method Test`1::.ctor

 

1、第一轮编译时，编译器只为Test<T>类型产生“泛型版”的IL代码与元数据——并不进行泛型的实例化，T在中间只充当占位符。例如：Test类型元数据中显示的<!T>

2、JIT编译时，当JIT编译器第一次遇到Test<int>时，将用int替换“范型版”IL代码与元数据中的T——进行泛型类型的实例化。例如：Main函数中显示的<int>

3、CLR为所有类型参数为“引用类型”的泛型类型产生同一份代码；但是如果类型参数为“值类型”，对每一个不同的“值类型”，CLR将为其产生一份独立的代码。因为实例化一个引用类型的泛型，它在内存中分配的大小是一样的，但是当实例化一个值类型的时候，在内存中分配的大小是不一样的。

 

C#泛型特点：

1、如果实例化泛型类型的参数相同，那么JIT编辑器会重复使用该类型，因此C#的动态泛型能力避免了C++静态模板可能导致的代码膨胀的问题。

2、C#泛型类型携带有丰富的元数据，因此C#的泛型类型可以应用于强大的反射技术。

3、C#的泛型采用“基类、接口、构造器，值类型/引用类型”的约束方式来实现对类型参数的“显示约束”，提高了类型安全的同时，也丧失了C++模板基于“签名”的隐式约束所具有的高灵活性

 

C#泛型继承：

C#除了可以单独声明泛型类型（包括类与结构）外，也可以在基类中包含泛型类型的声明。但基类如果是泛型类，它的类型要么以实例化，要么来源于子类（同样是泛型类型）声明的类型参数，看如下类型

class C<U,V>

class D:C<string,int>

class E<U,V>:C<U,V>

class F<U,V>:C<string,int>

class G:C<U,V>  //非法

E类型为C类型提供了U、V，也就是上面说的来源于子类

F类型继承于C<string,int>，个人认为可以看成F继承一个非泛型的类

G类型为非法的，因为G类型不是泛型，C是泛型，G无法给C提供泛型的实例化

 

泛型类型的成员：

泛型类型的成员可以使用泛型类型声明中的类型参数。但类型参数如果没有任何约束，则只能在该类型上使用从System.Object继承的公有成员。如下图：

 

 

泛型接口：

泛型接口的类型参数要么已实例化，要么来源于实现类声明的类型参数

 

泛型委托：

泛型委托支持在委托返回值和参数上应用参数类型，这些参数类型同样可以附带合法的约束

delegate bool MyDelegate<T>(T value);

class MyClass

{

    static bool F(int i){...}

    static bool G(string s){...}

    static void Main()

    {

        MyDelegate<string> p2 = G;

        MyDelegate<int> p1 = new MyDelegate<int>(F);

    }

}

 

泛型方法：

1、C#泛型机制只支持“在方法声明上包含类型参数”——即泛型方法。

2、C#泛型机制不支持在除方法外的其他成员（包括属性、事件、索引器、构造器、析构器）的声明上包含类型参数，但这些成员本身可以包含在泛型类型中，并使用泛型类型的类型参数。

3、泛型方法既可以包含在泛型类型中，也可以包含在非泛型类型中。

 

泛型方法声明：如下

public static int FunctionName<T>(T value){...}

 

泛型方法的重载：

public void Function1<T>(T a);

public void Function1<U>(U a);

这样是不能构成泛型方法的重载。因为编译器无法确定泛型类型T和U是否不同，也就无法确定这两个方法是否不同

 

public void Function1<T>(int x);

public void Function1(int x);

这样可以构成重载

 

public void Function1<T>(T t) where T:A;

public void Function1<T>(T t) where T:B;

这样不能构成泛型方法的重载。因为编译器无法确定约束条件中的A和B是否不同，也就无法确定这两个方法是否不同

 

泛型方法重写：

在重写的过程中，抽象类中的抽象方法的约束是被默认继承的。如下：

abstract class Base

{

    public abstract T F<T,U>(T t,U u) where U:T;

    public abstract T G<T>(T t) where T:IComparable;

}

 

class MyClass:Base

{

    public override X F<X,Y>(X x,Y y){...}

    public override T G<T>(T t) where T:IComparable{}

}

对于MyClass中两个重写的方法来说

F方法是合法的，约束被默认继承

G方法是非法的，指定任何约束都是多余的

 

泛型约束：

1、C#泛型要求对“所有泛型类型或泛型方法的类型参数”的任何假定，都要基于“显式的约束”，以维护C#所要求的类型安全。

2、“显式约束”由where子句表达，可以指定“基类约束”，“接口约束”，“构造器约束”，“值类型/引用类型约束”共四种约束。

3、“显式约束”并非必须，如果没有指定“显式约束”，范型类型参数将只能访问System.Object类型中的公有方法。例如：在开始的例子中，定义的那个obj成员变量。比如我们在开始的那个例子中加入一个Test1类，在它当中定义两个公共方法Func1、Func2，如下图：



下面就开始分析这些约束：

 

基类约束：

class A

    {

        public void Func1()

        { }

    }

 

    class B

    {

        public void Func2()

        { }

    }

 

    class C<S, T>

        where S : A

        where T : B

    {

        public C(S s,T t)

        {

            //S的变量可以调用Func1方法

            s.Func1();

            //T的变量可以调用Func2方法

            t.Func2();

        }

    }

接口约束：

interface IA<T>

    {

        T Func1();

    }

 

    interface IB

    {

        void Func2();

    }

 

    interface IC<T>

    {

        T Func3();

    }

 

    class MyClass<T, V>

        where T : IA<T>

        where V : IB, IC<V>

    {

        public MyClass(T t,V v)

        {

            //T的对象可以调用Func1

            t.Func1();

            //V的对象可以调用Func2和Func3

            v.Func2();

            v.Func3();

        }

    }

构造器约束：

class A

        {

            public A()

            { }

        }

 

        class B

        {

            public B(int i)

            { }

        }

 

        class C<T> where T : new()

        {

            T t;

            public C()

            {

                t = new T();

            }

        }

 

        class D

        {

            public void Func()

            {

                C<A> c =new C<A>();

                C<B> d = new C<B>();

            }

        }

    d对象在编译时报错：The type B must have a public parameterless constructor in order to use it as parameter 'T' in the generic type or method C<T>

    注意：C#现在只支持无参的构造器约束

    此时由于我们为B类型写入了一个有参构造器，使得系统不会再为B自动创建一个无参的构造器，但是如果我们将B类型中加一个无参构造器，那么对象d的实例化就不会报错了。B类型定义如下：

        classB

        {

            public B()

            { }

            public B(int i)

            { }

        }

值类型/引用类型：

public structA { }

        public class B { }

 

        public class C<T> where T :struct

        {

 

        }

 

        C<A> c1 =new C<A>();

        C<B> c2 = new C<B>();

    c2对象在编译时报错：The type 'B' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or methor 'C<T>'

   

总结：

1、C#的泛型能力由CLR在运行时支持，它既不同于C++在编译时所支持的静态模板，也不同于Java在编译器层面使用“擦拭法”支持的简单的泛型。

2、C#的泛型支持包括类、结构、接口、委托四种泛型类型，以及方法成员。

3、C#的泛型采用“基类，接口，构造器，值类型/引用类型”的约束方式来实现对类型参数的“显式约束”，它不支持C++模板那样的基于签名的隐式约束。

 

 

泛型听起来很高深的一个词，但实际上它的作用很简单，就是提高c#程序的性能。比如在计算机中经常用到一些数据结构，如队列，链表等，而其中的元素以前一般这么定义：object a=new object();这样就带来一个严重的问题，用object来表示元素没有逻辑问题，但每次拆箱、封箱就占用了大量的计算机资源，导致程序性能低下，而这部分内容恰恰一般都是程序的核心部分，如果使用object，那么程序的表现就比较糟糕。而使用泛型则很好的解决这个问题，本质就是在编译阶段就告诉编译器，数据结构中元素的种类，既然编译器知道了元素的种类，自然就避免了拆箱、封箱的操作，从而显著提高c#程序的性能。比如List<string>就直接使用string对象作为List的元素，而避免使用object对象带来的封箱、拆箱操作，从而提高程序性能。可以自己编个小例子体验一下在使用数据结构时的情形，自然就理解了。

tinary123
关注
.NET/C#如何判断某个类是否是泛型类型或泛型接口的子类型详解
10-18
因此，我们可以编写自定义的方法来实现泛型类型的判断。对于判断是否实现了泛型接口，可以编写如下方法： ```csharp public static bool HasImplementedRawGeneric(this Type type, Type generic) { return type....
深入浅析C#泛型类型
08-31
总的来说，C#的泛型类型系统提供了强大的工具，用于编写高度灵活且类型安全的代码。熟练掌握泛型可以帮助开发者编写出更加高效和可维护的程序。通过合理利用泛型，可以避免不必要的类型转换，减少运行时异常，并提高...
c#泛型编程
weixin_30388677的博客
07-04 182
为什么要使用泛型： 编写程序时，经常遇到两个模块功能非常相似，只是一个是处理int数据，另一个是处理string数据，或者其他自定义的数据类型，但我们只能分类写多个方法去处理每个数据类型，因为方法的参数类型不同。 上面的一种解决方法：如果我写一个object类型的类，它可以接收任何数据类型！ <----缺点：当他处理值类型时，会出现装箱拆箱操作，这会导致托管堆上分配和回收了大量的变量，若...
C# 泛型编程
黎明前的黑暗
07-29 7554
感觉对于编程这个工作，我开始一直是这样认为的，还是我们现在好。比如说语言发展了，发展成更容易理解和编程了；工具也发展了，编程的时候更方便了，比如说现在的智能提示。           但是这样理解好像有点片面了，如果不理解一个技术的发展历史就很难真正理解它。C# 泛型编程是2.0就有的，可是自己的理解还不够，特此好好总结一下。 C# 泛型及机制          C#泛型演示 using
C#泛型编程
weixin_33742618的博客
01-08 135
例子代码： class Program { static void Main(string[] args) { int obj = 2; Test&lt;int&gt; test = new Test&lt;int&gt;(obj); Console.WriteLine...
C#学习笔记10——C#泛型编程
深之JohnChen的专栏
08-31 2794
C#泛型编程 "一次编码，多次使用"，这就是引入泛型的根源。在以前的C++中称为模板，C#泛型通过算法和数据结构支持独立编码。例如，泛型列表意味着，你不必再重写一个强类型集合。在本文中，作者将向你展示定义和使用泛型是多么容易的事情-请注意，长期以来泛型一直被认为是最高级和最困难的
Java 中泛型类型概述
01-17
5. 泛型类型必须是一个合法的标识符，并且其类型会在实例化时由具体类型所取代。 6. 泛型类型之间不能直接相互赋值，即使它们是同一泛型类但具体的类型参数不同。 7. 泛型不支持重载方法，由于泛型会擦除具体的...
泛型类型转换Demo
10-31
在"泛型类型转换Demo"中，可能涉及到不同泛型类型的赋值转换。例如，如果我们有一个`List<Number>`，我们可以通过类型转换将其赋值给`List<Integer>`，因为Integer是Number的子类。但是，这种转换只能在满足继承...
C#泛型类型知识讲解
12-17
C#泛型提供了强大的功能，允许开发者编写高度灵活和类型安全的代码。通过理解和应用泛型，可以创建适应性强的集合类、方法和其他组件，同时减少类型转换和潜在的运行时错误。结合泛型约束，开发者可以更精确地控制...
C#编程：泛型编程
博客常用背景
12-08 481
泛型简单示例 using System; namespace ConsoleApp3 { class Program { static void Main(string[] args) { Apple ap = new Apple() { color="red"}; Book bo = new Book() { name="new book"}; Box<Apple> bo.
C#泛型
weixin_30345577的博客
04-12 132
class Program { static void Main(string[] args) { int obj = 2; Test<int> test = new Test<int>(obj); Console.WriteLine("int:" + test.o...
Unity添加MapToolbox报错
hubiao1235的博客
08-16 3238
Unity2021.3.8f1c1导入autowaremaptools报错Library\PackageCache\com.unity.jobs@0.2.10-preview.13\Unity.Jobs\IJobParallelForDefer.cs(73,85): error CS8377: The type 'U' must be a non-nullable value type......
java 泛型方法编写
最新发布
11-06
在 Java 中，**泛型方法**（Generic Method）是一种可以独立于类的泛型参数来操作多种数据类型的方法。它允许你编写更灵活、可重用且类型安全的代码。 --- ### ✅ 泛型方法的基本语法 ```java public static <T> 返回类型 方法名(T 参数) { // 方法体 } ``` - `<T>` 是类型参数声明，放在返回类型前。 - `T` 可以是任何字母：常用有 `T`（Type）、`E`（Element）、`K`（Key）、`V`（Value）等。 - 泛型方法可以在普通类或泛型类中定义。 --- ### 🌰 示例 1：最简单的泛型方法 —— 打印数组元素 ```java public class GenericMethodExample { // 泛型方法：打印任意类型的数组 public static <T> void printArray(T[] array) { for (T element : array) { System.out.print(element + " "); } System.out.println(); } public static void main(String[] args) { // 测试字符串数组 String[] strArray = {"apple", "banana", "cherry"}; printArray(strArray); // 测试整型数组 Integer[] intArray = {1, 2, 3, 4, 5}; printArray(intArray); // 测试双精度数组 Double[] doubleArray = {1.1, 2.2, 3.3}; printArray(doubleArray); } } ``` #### 输出： ``` apple banana cherry 1 2 3 4 5 1.1 2.2 3.3 ``` --- ### 🌰 示例 2：带多个泛型参数的方法 ```java public class GenericMethodExample { // 泛型方法：将键值对封装成字符串输出 public static <K, V> void displayPair(K key, V value) { System.out.println("Key: " + key + ", Value: " + value); } public static void main(String[] args) { displayPair("name", "Alice"); displayPair(100, "Employee ID"); displayPair("grade", 95.5); } } ``` #### 输出： ``` Key: name, Value: Alice Key: 100, Value: Employee ID Key: grade, Value: 95.5 ``` --- ### 🌰 示例 3：使用泛型方法返回最大值（要求实现 Comparable） ```java public class GenericMethodExample { // 泛型方法：找出三个同类型可比较对象中的最大值 public static <T extends Comparable<T>> T maximum(T a, T b, T c) { T max = a; if (b.compareTo(max) > 0) max = b; if (c.compareTo(max) > 0) max = c; return max; } public static void main(String[] args) { System.out.println("Max of 3, 7, 5 is: " + maximum(3, 7, 5)); System.out.println("Max of x, y, a is: " + maximum("x", "y", "a")); System.out.println("Max of 1.1, 3.3, 2.2 is: " + maximum(1.1, 3.3, 2.2)); } } ``` #### 输出： ``` Max of 3, 7, 5 is: 7 Max of x, y, a is: y Max of 1.1, 3.3, 2.2 is: 3.3 ``` > 🔍 注意：`<T extends Comparable<T>>` 表示 T 必须实现 `Comparable` 接口，这样才能调用 `.compareTo()` 方法。 --- ### 🌰 示例 4：泛型方法与集合结合使用 ```java import java.util.List; import java.util.ArrayList; public class GenericMethodExample { // 将数组转换为 List（泛型方法） public static <T> List<T> arrayToList(T[] array) { List<T> list = new ArrayList<>(); for (T item : array) { list.add(item); } return list; } public static void main(String[] args) { String[] fruits = {"Apple", "Banana", "Orange"}; List<String> fruitList = arrayToList(fruits); System.out.println("Fruit List: " + fruitList); Integer[] numbers = {1, 2, 3}; List<Integer> numberList = arrayToList(numbers); System.out.println("Number List: " + numberList); } } ``` #### 输出： ``` Fruit List: [Apple, Banana, Orange] Number List: [1, 2, 3] ``` --- ### ✅ 泛型方法 vs 普通方法的优势 | 对比项 | 普通方法 | 泛型方法 | |-------|--------|---------| | 类型安全性 | 需要强制转换，易出错 | 编译期检查，避免 ClassCastException | | 代码复用性 | 每种类型都要写一个方法 | 一个方法处理所有类型 | | 可读性和维护性 | 差 | 好 | --- ### ⚠️ 注意事项 1. **不能用于静态变量**：泛型方法可以是 `static`，但泛型类型不能用于类的静态字段。 2. **类型擦除**：Java 泛型在编译后会被擦除为 `Object` 或上界类型（如 `Comparable`），运行时无法获取真实类型。 3. **避免原生类型**：不要使用 `List` 而应使用 `List<T>`。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值