泛型--泛型方法、委托--介绍篇

一、简单知识和演示

1. public void page_load(object sender, EventArgs e)
2. {
3.     //把泛型类型赋予方法调用
4.     int x = 4;
5.     int y = 5;
6.     Check<int>(ref x, ref y);
7.  
8.     //由于C#编译器会通过调用Text方法来获取参数的
9.     //类型，所以也可以不把泛型类型赋予方法调用。
10.     //即泛型方法可以像非泛型方法那样调用
11.     Check(ref x, ref y);
12.  
13.     Response.Write(x + "--" + y);
14. }
15.  
16. //在泛型方法中，泛型类型用方法声明来定义
17. public void Check<T>(ref T x, ref T y)
18. {
19.     T temp = x;
20.     x = y;
21.     y = temp;
22. }

 

二、泛型方法和委托实例

1. //源代码下载路径：http://media.wiley.com/product_ancillary/41/07645753/DOWNLOAD/Ch10.zip
2. namespace GenericMethodDemo
3. {
4.     using System;
5.     using System.Collections;
6.     using System.Collections.Generic;
7.  
8.     public interface IAccount
9.     {
10.         string Name { get; }
11.         decimal Balance { get; }
12.     }
13.  
14.     public class Account : IAccount
15.     {
16.         private string name;
17.         public string Name
18.         {
19.             get { return name; }
20.         }
21.  
22.         private decimal balance;
23.         public decimal Balance
24.         {
25.             get { return balance; }
26.         }
27.  
28.         public Account(string name, Decimal balance)
29.         {
30.             this.name = name;
31.             this.balance = balance;
32.         }
33.     }
34.  
35.     public static class Algorithm
36.     {
37.         //一般的方法【参数为继承IEnumerable接口的类】
38.         public static decimal AccumulateSimple(IEnumerable e)
39.         {
40.             decimal sum = 0;
41.  
42.             foreach (Account a in e)
43.             {
44.                 sum += a.Balance;
45.             }//这里使用Account显示出一定局限性
46.  
47.             return sum;
48.         }
49.  
50.         //一般的泛型方法【参数为继承IEnumerable<T>泛型接口的类】
51.         public static decimal Accumulate<T>(IEnumerable<T> coll)
52.             where T : IAccount//接口约束--任然显示出一定得局限性，下面使用委托可以克服这种局限
53.         {
54.             decimal sum = 0;
55.  
56.             foreach (T a in coll)
57.             {
58.                 sum += a.Balance;
59.             }
60.  
61.             return sum;
62.         }
63.  
64.         //泛型委托
65.         public delegate U Adder<T, U>(T t, U u);
66.         //使用泛型委托的泛型方法
67.         public static U Accumulate<T, U>(IEnumerable<T> coll, Adder<T, U> adder)
68.         {
69.             U sum = default(U);//设置默认值
70.  
71.             foreach (T a in coll)
72.             {
73.                 sum = adder(a, sum);
74.             }
75.  
76.             return sum;
77.         }
78.         public static U AccumulateIf<T, U>(IEnumerable<T> coll, Adder<T, U> adder, Predicate<T> match)
79.         {
80.             U sum = default(U);
81.            
82.             foreach (T a in coll)
83.             {
84.                 if (match(a))
85.                     sum = adder(a, sum);
86.             }
87.  
88.             return sum;
89.         }
90.     }
91.  
92.     class Program
93.     {
94.         static void Main(string[] args)
95.         {
96.             List<Account> accounts = new List<Account>();
97.             accounts.Add(new Account("Christian", 1500));
98.             accounts.Add(new Account("Sharon", 2200));
99.             accounts.Add(new Account("Katie", 1800));
100.  
101.             //调用一般的方法
102.             Console.WriteLine("sum of all accounts {0}", Algorithm.AccumulateSimple(accounts));
103.             //调用一般的泛型方法
104.             Console.WriteLine("sum of all accounts {0}", Algorithm.Accumulate<Account>(accounts));
105.             //调用使用泛型委托的泛型方法
106.             Console.WriteLine("sum of all accounts {0}",
107.                 Algorithm.Accumulate<Account, decimal>(accounts, delegate(Account a, decimal d) { return a.Balance + d; }));//使用匿名委托
108.             Console.WriteLine("sum of all accounts {0}",
109.                 Algorithm.Accumulate<Account, decimal>(accounts, new Algorithm.Adder<Account, decimal>(AccountAdder)));//使用泛型委托
110.             Console.WriteLine("sum of all accounts {0}",
111.                 Algorithm.Accumulate<Account, decimal>(accounts, AccountAdder));
112.  
113.             Console.WriteLine(Algorithm.AccumulateIf<Account, decimal>(
114.                 accounts,
115.                 delegate(Account a, decimal d) { return a.Balance + d; },
116.                 delegate(Account a) { return a.Balance > 1800 ? true : false; }
117.                 ));//使用匿名委托
118.  
119.             Console.ReadLine();
120.         }
121.  
122.         //委托调用方法
123.         static decimal AccountAdder(Account a, decimal d)
124.         {
125.             return a.Balance + d;
126.         }
127.     }
128. }