泛型委托

1. #region Using directives
3. using System;
4. using System.Collections;
5. using System.Collections.Generic;
6. using System.Text;
8. #endregion
10. namespace GenericMethodDemo
11. {
12.   public static class Algorithm
13.   {
14.     //1.no operators with generics
15.     //public static T Max<T>(T x, T y)
16.     //{
17.     //  if (x > y)
18.     //    return x;
19.     //  else
20.     //    return y;
21.     //}
24.     //泛型方法Max；泛型委托Comparison<T>
25.     //A
26.     public static T Max<T>(T x, T y, Comparison<T> comparer)
27.     {
28.       int result = comparer(x, y);
30.       return result > 0 ? x : y;
31.     }
33.     //面向接口编程，只要参数实现了IEnumerable接口即可
34.     //B
35.     public static decimal AccumulateSimple(IEnumerable e)
36.     {
37.       decimal sum = 0;
38.       foreach (Account a in e)
39.       {
40.         sum += a.Balance;
41.       }
42.       return sum;
43.     }
45.     //泛型方法Accumulate
46.     //C
47.     public static decimal Accumulate<T, U>(U coll)
48.       where U : IEnumerable<T>
49.       where T : IAccount
50.     {
51.       decimal sum = 0;
53.       foreach (T a in coll)
54.       {
55.         sum += a.Balance;
56.       }
58.       return sum;
59.     }
61.     //泛型方法Accumulate
62.     //D
63.     public static decimal Accumulate<TAccount>(IEnumerable<TAccount> coll)
64.       where TAccount : IAccount
65.     {
66.       decimal sum = 0;
68.       foreach (TAccount a in coll)
69.       {
70.         sum += a.Balance;
71.       }
73.       return sum;
74.     }
77.     //定义委托Adder
78.     public delegate U Adder<T, U>(T t, U u);
81.     //泛型方法Accumulate；泛型委托Adder
82.     //E
83.     public static U Accumulate<T, U>(IEnumerable<T> coll, Adder<T, U> adder)
84.     {
85.       U sum = default(U);
87.       foreach (T a in coll)
88.       {
89.         sum = adder(a, sum);
90.       }
92.       return sum;
93.     }
95.     //泛型方法Accumulate；泛型委托Adder，Predicate
96.     //F
97.     public static U AccumulateIf<T, U>(IEnumerable<T> coll, Adder<T, U> adder, Predicate<T> match)
98.     {
99.       U sum = default(U);
101.       foreach (T a in coll)
102.       {
103.         if (match(a))
104.         {
105.           sum = adder(a, sum);
106.         }
107.       }
109.       return sum;
110.     }
111.   }
112.   
113.   public interface IAccount
114.   {
115.     decimal Balance { get; }
116.     string Name { get; }
117.   }  
118.   
119.   public class Account : IAccount
120.   {
121.     private string name;
122.     public string Name
123.     {
124.       get
125.       {
126.         return name;
127.       }
128.     }
130.     private decimal balance;
131.     public decimal Balance
132.     {
133.       get
134.       {
135.         return balance;
136.       }
137.     }
140.     public Account(string name, Decimal balance)
141.     {
142.       this.name = name;
143.       this.balance = balance;
144.     }
145.   }
147.   class Program
148.   {
149.     static int Compare(int x, int y)
150.     {
151.       if (x == y)
152.         return 0;
153.       else if (x < y)
154.         return -1;
155.       else
156.         return 1;
157.     }
159.     static decimal AccountAdder(Account a, decimal d)
160.     {
161.       return a.Balance + d;
162.     }
164.     static void Main(string[] args)
165.     {
166.       int i = 3;
167.       int j = 4;
168.       //A
169.       int result = Algorithm.Max<int>(i, j, new Comparison<int>(Program.Compare));
171.       List<Account> accounts = new List<Account>();
172.       accounts.Add(new Account("Christian", 1500));
173.       accounts.Add(new Account("Sharon", 2200));
174.       accounts.Add(new Account("Katie", 1800));
176.       foreach (Account a in accounts)
177.       {
178.         Console.WriteLine(a.Name);
179.       }
181.       //B
182.       decimal sum1 = Algorithm.AccumulateSimple(accounts);
183.       Console.WriteLine(sum1);
185.       //D
186.       decimal sum2 = Algorithm.Accumulate(accounts);
188.       Console.WriteLine("sum of all accounts {0}", Algorithm.Accumulate<Account>(accounts));
189.       
190.       
191.       //C
192.       decimal sum_test = Algorithm.Accumulate<Account, List<Account>>(accounts);      
193.       Console.WriteLine(sum_test);
194.       
196.       //E
197.       decimal sum3 = Algorithm.Accumulate<Account, decimal>(accounts, new Algorithm.Adder<Account, decimal>(AccountAdder));
198.       Console.WriteLine(sum3);
200.       //E
201.       decimal sum3b = Algorithm.Accumulate<Account, decimal>(accounts, AccountAdder);
202.       Console.WriteLine("3b " + sum3b);
204.       //E
205.       decimal sum4 = Algorithm.Accumulate<Account, decimal>(accounts,
206.         delegate(Account a, decimal d) { return a.Balance + d; });
207.       Console.WriteLine(sum4);
210.       //F
211.       decimal sum5 = Algorithm.AccumulateIf<Account, decimal>(
212.         accounts,
213.         delegate(Account a, decimal d) { return a.Balance + d; },
214.         delegate(Account a) { return a.Balance > 1800 ? true : false; });
216.       Console.WriteLine(sum5);      
218.     }
219.   }
220. }