泛型约束以及带委托的泛型方法

namespace start006
{
/// <summary>
/// 声明一个带有两个属性的接口
/// </summary>
public interface IAccount
{
string Name { get; }
int Money { get; }
}

/// <summary>
/// Account类实现上面的接口带一个构造函数
/// </summary>
public class Account:IAccount
{
private string name;
private int money;

string IAccount.Name
{
get { return name; }
}
int IAccount.Money
{
get { return money; }
}
public Account(string n, int m)
{
name = n;
money = m;
}
}

/// <summary>
/// 算法类实现一个带约束的泛型方法
/// </summary>
public static class Alogrithm
{
public static int AccumulateSimple<TAccount>(IEnumerable<TAccount> source) where TAccount:IAccount
{
int sum = 0;
foreach (var it in source)
{
sum += it.Money;
}
return sum;
}
}

/// <summary>
/// 主程序测试类
/// </summary>
class Program
{
static void Main(string[] args)
{
List<Account> accountSum = new List<Account>();
accountSum.Add(new Account("xiaolan",45));
accountSum.Add(new Account("kenan", 78));
Console.WriteLine(Alogrithm.AccumulateSimple(accountSum));
Console.Read();
}
}
}

namespace start007
{
/// <summary>
/// Account类
/// </summary>
public class Account
{
public string name;
public int money;

public Account(string n, int m)
{
name = n;
money = m;
}
}

/// <summary>
/// 算法类实现一个带委托的泛型方法
/// </summary>
public static class Alogrithm
{
public static T2 AccmulateSimple<T1,T2>(IEnumerable<T1> source,Func<T1,T2,T2> action)
{
T2 sum = default(T2); //default
foreach(T1 item in source)
{
sum = action(item,sum);
}
return sum;
}
}

/// <summary>
/// 主程序测试类
/// </summary>
class Program
{
static void Main(string[] args)
{
List<Account> accountSum = new List<Account>();
accountSum.Add(new Account("xiaolan",45));
accountSum.Add(new Account("kenan", 78));
Console.WriteLine(Alogrithm.AccmulateSimple<Account,int>(accountSum,(item,sum)=>sum+item.money));
Console.Read();
}
}
}