泛型交换方法

版权声明：转载 请说明 https://blog.csdn.net/qq2512667/article/details/82929679

void swap<T>(ref T x,ref T y)
{
      T temp=x;
       x=y;
       y=temp;
}
static void Main()
{
      int x=3,y=4;
      swap<int>(ref x,ref y);

}

加上ref 关键字 就可以按址传递了，ref可出可进，out只进不出。都是按址传递；意思就是out传进方法里的时候，需要初始化；

foreach迭代：一般foreach迭代器需要有迭代的对象继承 IEnumerable<T>/IEnumerable ，而List 是继承 IEnumerable<T>的,因次可以进行foreach；迭代，比如要统计一个list里面的所有账目；

    public Interface IAccount
    {
     string Name{get;};decimal Balance{get;};
    }
   public class Account：IAccount
        {    //decimal 十进制的意思
            public string Name { get; }
            public decimal Balance{ get; private set; }
            public Account(string name, Decimal balance)
            {
                Name = name;
                Balance = balance;
            }

        }

public static class Algorithms<T> where T:IAccount
{
    public static decimal AccumulateSimple(IEnumerable<T> source)    
    {
       decimal sum=0;
        foreach(T a in source)
        {
            sum=a.Balance;
        }
        return sum;
    }
    //使用泛型委托 Func
    public static T2 Accumulate<T1,T2>(IEnumerable<T1> source,Func<T1,T2,T2> func)    
    {
       T2 sum= default(T2);//默认值为0/null
        foreach(T1 item in source)
        {
            sum+=func(item,sum);
        }
        return sum;
    }
}

static void main()
{
    var accounts = new List<Account>()
            {
                new Account("C",1500),

                new Account("S",2200),

                new Account("A",1800),

                new Account("m",2400),
            };
            decimal amount = Algorithms<Account>.AccumulateSimple(accounts);
        //调用 泛型方法
            decimal amount = Algorithms.Accumulate<Account,decimal>(accounts,(item,sum)=> sum+=item.Balance);
}

加了泛型约束 方便扩展；