`
starnc
  • 浏览: 145140 次
  • 性别: Icon_minigender_1
  • 来自: 火星
社区版块
存档分类
最新评论

c#泛型(包括泛型抽象类的继承)

    博客分类:
  • .NET
阅读更多
1.泛型和泛型强制转换

 using System;
 using System.Collections.Generic;
 using System.Text;
 
 namespace VS2005Demo2
 6{
 7
 8    C# 编译器只允许将泛型参数隐式强制转换到 Object 或约束指定的类型#region  C# 编译器只允许将泛型参数隐式强制转换到 Object 或约束指定的类型
 9    public interface ISomeInterface
10    { }
11    class BaseClass
12    { }
13    class MyClass<T> where T : BaseClass, ISomeInterface
14    {
15        void SomeMethod(T t)
16        {
17            ISomeInterface obj1 = t;
18            BaseClass obj2 = t;
19            object obj3 = t;
20        }
21    }
22    #endregion
23
24    编译器允许您将泛型参数显式强制转换到其他任何接口,但不能将其转换到类#region 编译器允许您将泛型参数显式强制转换到其他任何接口,但不能将其转换到类
25    class SomeClass
26    { }
27    //class MyClass1<T>
28    //{
29    //    void SomeMethod(T t)
30    //    {
31    //        ISomeInterface obj1 = (ISomeInterface)t;  //Compiles
32    //        SomeClass obj2 = (SomeClass)t;           //Does not compile
33    //    }
34    //}
35    #endregion
36
37
38    使用临时的 Object 变量,将泛型参数强制转换到其他任何类型#region 使用临时的 Object 变量,将泛型参数强制转换到其他任何类型
39    class MyClass2<T>
40    {
41        void SomeMethod(T t)
42        {
43            object temp = t;
44            SomeClass obj = (SomeClass)temp;
45        }
46    }
47    #endregion
48
49    使用is和as运算符#region 使用is和as运算符
50    public class MyClass3<T>
51    {
52        public void SomeMethod(T t)
53        {
54            if (t is int) { }
55            if (t is LinkedList<int, string>) { }
56            string str = t as string;
57            if (str != null) { }
58            LinkedList<int, string> list = t as LinkedList<int, string>;
59            if (list != null) { }
60        }
61    }
62    #endregion
63
64}
65

2.继承和泛型

  1using System;
  2using System.Collections.Generic;
  3using System.Text;
  4
  5namespace VS2005Demo2
  6{
  7    继承和泛型#region 继承和泛型
  8    public class BaseClass<T>
  9    { }
 10    public class SubClass : BaseClass<int>
 11    { }
 12
 13
 14    public class SubClass1<R> : BaseClass<R>
 15    { }
 16    #endregion
 17
 18    继承约束#region 继承约束
 19    public class BaseClass1<T> where T : ISomeInterface
 20    { }
 21    public class SubClass2<T> : BaseClass1<T> where T : ISomeInterface
 22    { }
 23
 24    //构造函数约束
 25    public class BaseClass3<T> where T : new()
 26    {
 27        public T SomeMethod()
 28        {
 29            return new T();
 30        }
 31    }
 32    public class SubClass3<T> : BaseClass3<T> where T : new()
 33    { }
 34
 35    #endregion
 36
 37    虚拟方法#region 虚拟方法
 38    public class BaseClass4<T>
 39    {
 40        public virtual T SomeMethod()
 41        {
 42            return default(T);
 43        }
 44    }
 45    public class SubClass4 : BaseClass4<int>
 46    {
 47        public override int SomeMethod()
 48        {
 49            return 0;
 50        }
 51    }
 52
 53    public class SubClass5<T> : BaseClass4<T>
 54    {
 55        public override T SomeMethod()
 56        {
 57            return default(T);
 58        }
 59    }
 60
 61    #endregion
 62
 63    接口、抽象类继承#region 接口、抽象类继承
 64    public interface ISomeInterface6<T>
 65    {
 66        T SomeMethod(T t);
 67    }
 68    public abstract class BaseClass6<T>
 69    {
 70        public abstract T SomeMethod(T t);
 71    }
 72    public class SubClass6<T> : BaseClass6<T>,ISomeInterface6<T>
 73    {
 74        public override T SomeMethod(T t)
 75        { return default(T); }
 76    }
 77    #endregion
 78
 79    泛型抽象方法和泛型接口#region 泛型抽象方法和泛型接口
 80    //public class Calculator<T>
 81    //{
 82    //    public T Add(T arg1, T arg2)
 83    //    {
 84    //        return arg1 + arg2;//Does not compile 
 85    //    }
 86    //    //Rest of the methods 
 87    //}
 88
 89    public abstract class BaseCalculator<T>
 90    {
 91        public abstract T Add(T arg1, T arg2);
 92        //public abstract T Subtract(T arg1, T arg2);
 93        //public abstract T Divide(T arg1, T arg2);
 94        //public abstract T Multiply(T arg1, T arg2);
 95    }
 96    public class MyCalculator : BaseCalculator<int>
 97    {
 98        public override int Add(int arg1, int arg2)
 99        {
100            return arg1 + arg2;
101        }
102        //Rest of the methods 
103    }
104
105    public interface ICalculator<T>
106    {
107        T Add(T arg1, T arg2);
108        //Rest of the methods 
109    }
110    public class MyCalculator1 : ICalculator<int>
111    {
112        public int Add(int arg1, int arg2)
113        {
114            return arg1 + arg2;
115        }
116        //Rest of the methods 
117    }
118    #endregion
119
120}
121

3.泛型方法

  1using System;
  2using System.Collections.Generic;
  3using System.Text;
  4
  5namespace VS2005Demo2
  6{
  7
  8    泛型方法#region 泛型方法
  9    public class MyClass
 10    {
 11        public void MyMethod<T>(T t)
 12        { }
 13    }
 14
 15    public class Class3
 16    {
 17        public void Test()
 18        {
 19            MyClass obj = new MyClass();
 20            obj.MyMethod<int>(3);
 21
 22            obj.MyMethod(3);
 23        }
 24    }
 25    #endregion
 26
 27    编译器无法只根据返回值的类型推断出类型#region 编译器无法只根据返回值的类型推断出类型
 28    public class MyClass1
 29    {
 30        public T MyMethod<T>()
 31        { return default(T); }
 32    }
 33
 34    public class Class31
 35    {
 36        public void Test()
 37        {
 38
 39            MyClass1 obj = new MyClass1();
 40            int number = obj.MyMethod<int>();
 41        }
 42    }
 43    #endregion
 44
 45    泛型方法约束#region 泛型方法约束
 46    public class Class32
 47    {
 48        public T MyMethod<T>(T t) where T : IComparable<T>
 49        { return default(T); }
 50    }
 51    #endregion
 52
 53    泛型虚拟方法#region 泛型虚拟方法
 54    public class BaseClass33
 55    {
 56        public virtual void SomeMethod<T>(T t)
 57        { }
 58    }
 59    public class SubClass33 : BaseClass33
 60    {
 61        public override void SomeMethod<T>(T t)
 62        {
 63            base.SomeMethod<T>(t);
 64        }
 65    }
 66
 67    public class BaseClass34
 68    {
 69        public virtual void SomeMethod<T>(T t) where T : new()
 70        { }
 71    }
 72    public class SubClass34 : BaseClass34
 73    {
 74        public override void SomeMethod<T>(T t)// where T : IComparable<T>
 75        { }
 76    }
 77
 78    public class BaseClass35
 79    {
 80        public virtual void SomeMethod<T>(T t)
 81        { }
 82    }
 83    public class SubClass35 : BaseClass35
 84    {
 85        public override void SomeMethod<T>(T t)
 86        {
 87            base.SomeMethod<T>(t);
 88            base.SomeMethod(t);
 89        }
 90    }
 91    #endregion
 92
 93    泛型静态方法#region 泛型静态方法
 94    public class MyClass36<T>
 95    {
 96        public static T SomeMethod(T t)
 97        { return default(T); }
 98    }
 99
100    public class Class36
101    {
102        public void Test()
103        {
104            int number = MyClass36<int>.SomeMethod(3);
105        }
106    }
107
108    public class MyClass37<T>
109    {
110        public static T SomeMethod<X>(T t, X x)
111        { return default(T); }
112    }
113    public class Class37
114    {
115        public void Test()
116        {
117            int number = MyClass37<int>.SomeMethod<string>(3, "AAA");
118            int number1 = MyClass37<int>.SomeMethod(3, "AAA");
119        }
120    }
121
122    public class MyClass38
123    {
124        public static T SomeMethod<T>(T t) where T : IComparable<T>
125        {  return default(T); }
126    }
127
128    #endregion
129}
130

4.泛型委托

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4
 5namespace VS2005Demo2
 6{
 7    泛型委托#region 泛型委托
 8    public class MyClass40<T>
 9    {
10        public delegate void GenericDelegate(T t);
11        public void SomeMethod(T t)
12        { }
13    }
14
15    public class MyClassTest40
16    {
17        public void Tests()
18        {
19            MyClass40<int> obj = new MyClass40<int>();
20            MyClass40<int>.GenericDelegate del;
21
22            del = new MyClass40<int>.GenericDelegate(obj.SomeMethod);
23            del(3);
24
25            //委托推理
26            del = obj.SomeMethod;
27
28        }
29    }
30    #endregion
31
32    委托泛型参数#region 委托泛型参数
33    public class MyClass41<T>
34    {
35        public delegate void GenericDelegate<X>(T t, X x);
36    }
37
38    //外部委托
39    public delegate void GenericDelegate<T>(T t);
40
41    public class MyClass42
42    {
43        public void SomeMethod(int number)
44        { }
45    }
46
47    public class MyClassTest42
48    {
49        public void Test()
50        {
51            MyClass42 obj = new MyClass42();
52            GenericDelegate<int> del;
53            //del = new GenericDelegate<int>(obj.SomeMethod);
54
55            del = obj.SomeMethod;
56            del(3);
57
58        }
59    }
60
61    #endregion
62
63    委托泛型参数#region 委托泛型参数
64    public delegate void MyDelegate<T>(T t) where T : IComparable<T>;
65    #endregion
66
67    事件#region 事件
68
69    public delegate void GenericEventHandler<S, A>(S sender, A args);
70    
71    public class MyPublisher
72    {
73        public event GenericEventHandler<MyPublisher, EventArgs> MyEvent;
74        public void FireEvent()
75        {
76            MyEvent(this, EventArgs.Empty);
77        }
78    }
79
80    public class MySubscriber<A> //Optional: can be a specific type
81    {
82        public void SomeMethod(MyPublisher sender, A args)
83        { }
84    }
85    public class MyClassTest43
86    {
87        public void Test()
88        {
89            MyPublisher publisher = new MyPublisher();
90            MySubscriber<EventArgs> subscriber = new MySubscriber<EventArgs>();
91            publisher.MyEvent += subscriber.SomeMethod;
92        }
93    }
94    #endregion
95}

 

分享到:
评论

相关推荐

    C#泛型学习和理解代码示例

    泛型类型可以实现接口或继承抽象类。例如,`GenericStack&lt;T&gt;`可以实现`IList&lt;T&gt;`接口,从而获得所有列表操作。 11. **泛型的类型安全性和性能**: 使用泛型可以确保类型安全,避免了不必要的类型转换。此外,由于...

    C#泛型学习实例

    在C#中,泛型主要体现在泛型类、泛型方法、泛型接口、泛型抽象类以及泛型抽象方法等方面。下面将详细解释这些概念,并通过实例说明它们的使用。 1. **泛型类**:泛型类是在声明类时定义了一个或多个类型参数的类。...

    c#泛型详解,泛型方法,泛型类

    在C#中,泛型通过参数化类型来实现,这意味着可以在一个泛型类或方法中使用一个或多个类型参数,这些参数将在实际使用时被具体的类型替换。这种抽象类型的能力使得泛型成为提高代码复用性和效率的有效工具。 C#作为...

    细细品味C#(泛型专题)

    随着对C#泛型特性的深入理解,可以着手构建更加复杂的泛型数据结构,如可反转排序的泛型字典类。这类数据结构通常需要实现多个接口,包括但不限于`IDictionary, TValue&gt;`、`IEnumerable&lt;T&gt;`等,并可能涉及到泛型约束...

    C#泛型详解由入门到精通.docx

    以下是对C#泛型的详细介绍: 1. **泛型简介** - 泛型的主要目标是提供类型安全和效率。在泛型之前,为了实现类似功能,开发者往往需要为每种数据类型编写单独的方法或类,这导致了大量的代码重复。 - 泛型引入了...

    C#泛型介绍

    3. **代码复用**:泛型类和方法可以用于多种不同的数据类型,提供了强大的抽象能力,提高了代码的复用性。 4. **减少冗余代码**:使用泛型,开发者无需为每种数据类型都编写独立的容器或算法实现。 **泛型的应用...

    C#面向对象高级:接口与抽象类的深度解析及应用场景

    最后,讨论了接口与抽象类在设计模式(如工厂模式和策略模式)中的应用,以及泛型接口和泛型抽象类的实现。 适合人群:具有C#基础并希望深入了解面向对象高级特性的开发者。 使用场景及目标:通过学习本文,开发者...

    泛型集合泛型集合泛型集合

    虽然两者都提供参数化类型的支持,但C#泛型在语法上更为简洁,且在实现上,C#的类型替换是在运行时完成的,这意味着泛型类型信息得以保留。与C++模板相比,C#泛型不支持一些高级特性,如非类型模板参数、显式或部分...

    泛型类(C#实例说明)

    总结起来,泛型类在C#中提供了强大的抽象能力,使我们能编写灵活、高效且类型安全的代码。通过实例化泛型类,我们可以针对不同的数据类型创建对象,而无需重复编写相同逻辑的代码。同时,类型约束确保了代码的正确性...

    C_泛型集合

    2. **自定义集合类**:从CollectionBase抽象类派生出新的类,为每个需要的类型创建一个自定义集合。这种方法虽然提供了强类型保证,但需要大量重复的编码工作。 泛型集合的出现解决了这些问题。它允许开发者创建...

    深入剖析C#语言面向对象编程中的泛型机制及其应用场景

    通过类、对象、继承、多态、接口和抽象类的面向对象特性,配合泛型类、方法、类型参数、约束以及其编译时和运行时的实现原理,C#为开发者提供了一种高效且强大的编程手段,广泛适用于集合、算法、数据结构等应用场景...

    采用普通类,接口,和抽象类实现单继承和多继承增,删,改,查

    本主题将深入探讨如何使用普通类、接口和抽象类来实现这些继承方式,并应用到“增、删、改、查”(CRUD,Create, Read, Update, Delete)操作中。 首先,单继承是指一个子类只能继承一个父类的特性。这种方式使得...

    C#面向对象编程基础及泛型与集合的应用

    内容概要:本文详细介绍了 C# 中面向对象编程的基础概念,包括类与对象、继承与多态、封装与抽象。此外,还涵盖了 C# 中的泛型概念及其优势,集合框架的使用,特别是 List 和 Dictionary 的创建、操作与性能比较。...

    Dart中的泛型 泛型方法 泛型类 泛型接口、库 自定义库、系统库、第三方库.zip

    3. **泛型接口**:虽然Dart没有像Java或C#那样明确定义接口的语法,但通过抽象类或带有抽象方法的类,我们可以实现类似的功能。泛型接口通常用于定义一组操作,这些操作可以应用于不同类型的对象。例如,`abstract ...

    数据工厂泛型类源码

    1. **定义泛型接口或抽象类**:首先,我们可以创建一个泛型接口(如`IDataFactory&lt;T&gt;`),其中`T`是类型参数,表示将要创建的对象的类型。 2. **实现泛型接口**:然后,我们创建一个具体的工厂类(如`...

    C# 2.0中泛型编程初级入门教程.pdf

    在C# 2.0中,可以通过在类名后加上尖括号`&lt; &gt;`,并在尖括号内声明类型参数来定义泛型类。例如: ```csharp public class Stack { private T[] m_item; public T Pop() { /* ... */ } public void Push(T item)...

    Java泛型类型擦除后的补偿

    然而,Java的泛型并非像C++或C#那样在运行时存在,而是在编译期间经历一个称为“类型擦除”的过程。这个过程会将泛型信息消除,代之以相应的原始类型,以确保与Java早期版本的兼容性。本文将深入探讨Java泛型类型...

    泛型教学视频

    在深入学习泛型的同时,课程还会涉及泛型与多态性的关系,如何通过泛型实现接口和抽象类,以及泛型与面向对象设计原则的结合。这将帮助开发者更好地利用泛型来设计出灵活、可扩展的代码结构。 课程中提供的PPT教材...

    C#编程规则与技巧

    C#泛型代码在编译为IL代码和元数据时,会使用特殊的占位符来表示泛型类型,并用特定的IL指令支持泛型操作。JIT编译器在“on-demand”的方式下进行泛型实例化,避免了C++静态模板可能导致的代码膨胀问题。C#泛型还...

Global site tag (gtag.js) - Google Analytics