泛型方法

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
4. using System.Collections;
6. namespace Generic_Method
7. {
8.   /*
9.   //-------第一种方案--普通方法---------
10.   public class Account
11.   {
12.     private string name;
13.     public string Name
14.     {
15.       get { return name; }
16.     }
18.     private decimal balance;
19.     public decimal Balance
20.     {
21.       get { return balance; }
22.     }
24.     public Account(string name, decimal balance)
25.     {
26.       this.balance = balance;
27.       this.name = name;
28.     }
29.   }
31.   public static class Algorithm
32.   {
33.     //面对接口编程，只要参数实现了IEnumerable接口就行；
34.     //比如Main函数里的List<Account> accounts；
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.     }
44.   }
46.   class Program
47.   {
48.     static void Main(string[] args)
49.     {
50.       List<Account> accounts = new List<Account>();
51.       accounts.Add(new Account("a", 1500));
52.       accounts.Add(new Account("b", 2000));
53.       accounts.Add(new Account("c", 2500));
55.       decimal amount = Algorithm.AccumulateSimple(accounts);
57.       Console.WriteLine(amount);
58.     }
59.   }
60.   */
63.   //-------第二种方案--使用泛型编码---------
65.   public interface IAccount
66.   {
67.     string Name
68.     { get;}
70.     decimal Balance
71.     { get;}
72.   }
74.   public class Account : IAccount
75.   {
76.     private string name;
77.     public string Name
78.     {
79.       get { return name; }
80.     }
82.     private decimal balance;
83.     public decimal Balance
84.     {
85.       get { return balance; }
86.     }
88.     public Account(string name, decimal balance)
89.     {
90.       this.balance = balance;
91.       this.name = name;
92.     }
93.   }
95.   public static class Algorithm
96.   {
97.     //面对接口编程，只要参数实现了IEnumerable接口就行；
98.     //比如Main函数里的List<Account> accounts；
100.     //where 子句可以用于泛型类也可以用于泛型方法
101.     public static decimal AccumulateSimple<TAccount> (IEnumerable<TAccount> coll)
102.       where TAccount:IAccount
103.     {
104.       decimal sum = 0;
105.       foreach (TAccount a in coll)
106.       {
107.         sum += a.Balance;
108.       }
109.       return sum;
110.     }
111.   }
113.   class Program
114.   {
115.     static void Main(string[] args)
116.     {
117.       List<Account> accounts = new List<Account>();
118.       accounts.Add(new Account("a", 1500));
119.       accounts.Add(new Account("b", 2000));
120.       accounts.Add(new Account("c", 2500));
122.       decimal amount = Algorithm.AccumulateSimple(accounts);
124.       Console.WriteLine(amount);
125.     }
126.   }
128. }