c#泛型學習(二)

2019-11-18 17:14:45

字體：大中小

來源：轉載

供稿：網友

1.泛型和泛型強制轉換

1using System;
2using System.Collections.Generic;
3using System.Text;
4
5namespace 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}
96
記錄一下