委托、事务

委托（普通、多播）delegate OutParm delegateName（InParm1,InParm2,......）

类似于函数指针  Delegate int Mydelegate(int a,int b)

用处：回调函数、 传递表达式 （lambda表达式：实质为泛型委托）

内置泛型委托 

Aciton<int,int> 最多支持16个参数

Func<int,int,int>  最多支持16个参数，最后一个为返回参数

  //定义实现Where方法

  public delegate bool WhereRuler(object obj);
    public static class ListExpandMethod
    {
        public static void NewWhere(this List<object> list, WhereRuler rule)
        {
            List<object> newlist = new List<object>();
            foreach (var item in list)
            {
                if (rule(item))
                {
                    newlist.Add(item);
                }
            }
            list.RemoveAll(c=>true);
            list.AddRange(newlist);
        }
    }

//调用
List<object> list=new List<object>() { "dai","wei","daiweikuan","wdwdw"};
list.NewWhere(c => c.ToString() == "dai");

 

事件    event delegateName eventName

事件是一种特殊委托类型的实例,一般作为类成员，主要作用是当类的内部成员发生改变时，能通知类外部的订阅者

和委托的区别是，限定了委托了在类外部的访问权限，只能订阅，无法进行初始化

/// <summary>
/// 规则类
/// </summary>
public class RuleClass
{
private Func<List<int>, int> rule;

public Func<List<int>, int> Rule
{
get { return rule; }
set { rule = value; if(RuleChange!=null)RuleChange.Invoke(); }
}

public event Action RuleChange;

public void GetMax(List<int> ints)
{
if (Rule != null)
{
Console.WriteLine($"Max Is {Rule(ints)}");
}
else { Console.Write("Rule no set"); }

}
}

/// <summary>
/// 接收事件通知类
/// </summary>
public class NoticeClass
{
public void NoticeRuleChange()
{
Console.WriteLine("Rule Is Changed");
}
}



//调用
List<int> ints=new List<int>() { 2,3,45,334,2,0};
NoticeClass noticeClass= new NoticeClass();
RuleClass ruleClass = new RuleClass();
ruleClass.RuleChange += noticeClass.NoticeRuleChange; //订阅规则改变事件
ruleClass.SetRule((list) => { return list[0]; }); //规则发生改变
Console.WriteLine(ruleClass.GetMax(ints));