泛型方法

约束类：

    class Program
    {
        static void Main(string[] args)
        {
            List<Account> list = new List<Account>();
            list.Add(new Account("张三", 156345.5M));
            list.Add(new Account("王磊", 15634123));
            Console.WriteLine( Algorithm.AccumulateSimple(list));
            Console.Read();
        }
    }
    // 定义一个账户类
    public class Account
    {
        public string Name{get;private set;}
        public decimal Balance { get; private set; }
        public Account(string name, decimal balance)
        {
            this.Name = name;
            this.Balance = balance;
        }
    }
    // 定义一个算法类
    public static class Algorithm
    {
        // 统计金额
        public static decimal AccumulateSimple(IEnumerable<Account> source)
        {
            decimal sum = 0;
            foreach (Account a in source)
            {
                sum += a.Balance;
            }
            return sum;
        }
    }

只能作用于Account类，如果要避免这个问题，可以通过where子句来限制；

  class Program
    {
        static void Main(string[] args)
        {
            List<Account> list = new List<Account>();
            list.Add(new Account("张三", 156345.5M));
            list.Add(new Account("王磊", 15634123));
            Console.WriteLine(Algorithm.AccumulateSimple(list));
            Console.Read();
        }
    }
    public interface IAccount
    {
        string Name { get; }
        decimal Balance { get; }
    }
    // 定义一个账户类
    public class Account : IAccount
    {
        public string Name { get; private set; }
        public decimal Balance { get; private set; }
        public Account(string name, decimal balance)
        {
            this.Name = name;
            this.Balance = balance;
        }
    }
    // 定义一个算法类
    public static class Algorithm
    {
        // 统计金额
        public static decimal AccumulateSimple(IEnumerable<IAccount> source)
        {
            decimal sum = 0;
            foreach (IAccount a in source)
            {
                sum += a.Balance;
            }
            return sum;
        }
    }

但是泛型实现IAccount接口的要求还是过于严格。为什么要实现IAccount接口，因为Accumulate方法中需要用到IAccount的属性。

所以可以通过传递一个泛型委托来修改Accumulate()方法，这样就不需要实现IAccount接口了。

class Program
    {
        static void Main(string[] args)
        {
            List<Account> list = new List<Account>();
            list.Add(new Account("张三", 156345.5M));
            list.Add(new Account("王磊", 15634123));
            //Console.WriteLine(Algorithm.AccumulateSimple<Account,decimal>(list,(item,sum)=>sum +=item.Balance));
            Console.WriteLine(Algorithm.AccumulateSimple<Account, decimal>(list, Summary));
            Console.Read();
        }
        public static decimal Summary(Account item, decimal sum)
        {
            sum += item.Balance;
            return sum;
        }
    }
    // 定义一个账户类
    public class Account
    {
        public string Name { get; private set; }
        public decimal Balance { get; private set; }
        public Account(string name, decimal balance)
        {
            this.Name = name;
            this.Balance = balance;
        }
    }
    // 定义一个算法类
    public static class Algorithm
    {
        public static T2 AccumulateSimple<T1, T2>(IEnumerable<T1> source, Func<T1, T2, T2> func)
        {
            T2 sum = default(T2);
            foreach (T1 item in source)
            {
                func(item, sum);
            }
            return sum;
        }
    }

Func<T1,T2,TResult>,最后的是返回值。这里TResult和T2类型相同。