委托

委托

delegate void Foo();

本质上是引用类型，需要被实例化，实例化时需要传入一个函数。

var foo = new Foo(Method);
foo += Method2;
foo -= Method;
//两种调用方法：
foo();
foo.Invoke();

委托可以为空（声明后减掉）。

回调函数

var callback = new Callback(MyCallback);

HeavyJob(callback);

void HeavyJob(Callback callback)
{
    Thread.Sleep(1500);
    callback.Invoke();
}

void MyCallback() => "Job is done.".Dump();

var rule = new MyRule(ChooseBiggerInteger);
PickOne(5, 10, rule);

void PickOne(int x, int y, MyRule rule)
{
    if(rule.Invoke(x, y)) x.Dump();
    else y.Dump();
}

bool ChooseBiggerInteger(int x, int y) => x >= y ;

delegate bool MyRule(int x, int y);

泛型

var add = new Add<int>(AddMethod);
Method( 5, 1000, add ).Dump();

int Method( int x, int y, Add<int> add) => add.Invoke(x, y);

int AddMethod(int x, int y) => x + y;

delegate int Add<T>(T x, T y);

.Net提供的强类型委托：Action, Func

Action无返回值，Func有返回值

var myrule = new Func<int, double, bool>(MyRule);
PickOne(5, 6.5555, myrule).Dump();

object PickOne(int x, double y, Func<int, double, bool> rule)
{
    if(rule(x, y)) return x;
    return y;
}

bool MyRule(int x, double y) => x > y;

这个例子中返回值为bool，放入Func的第三个参数中表示，前两个表示T1、T2

匿名委托：把方法声明省略：

PickOne(5, 6.5555, delegate (int a, double b) {return a > b;}).Dump();

object PickOne(int x, double y, Func<int, double, bool> rule)
{
    if(rule(x, y)) return x;
    return y;
}

lambda表达式

PickOne(5, 11.5555, ( a , b ) => a > b ).Dump();

object PickOne(int x, double y, Func<int, double, bool> rule)
{
    if(rule(x, y)) return x;
    return y;
}

关于lambda表达式：

var f = (int a, int b) => a > b;   //Func
var f0 = (int a) => a++; //Func
var f1 = (int a) => {a++;} ; //Action 
//此处var是Action<int>类型，在C#10.0后引入委托类型的自动推测

f.Dump();
f0.Dump();
f1.Dump();

事件

事件只可以+= 或 -= ，不能赋值，赋值的话就成委托字段了！！（真抽象）

var demo = new Demo();
demo.MyEvent += () => "hello".Dump();  
// 匿名lambda  等同于 delegate() { "hello".Dump(); }

demo.InvokeEvent();

class Demo
{
    public event Action MyEvent;
    
    public void InvokeEvent() => MyEvent?.Invoke();
}

常见场景：订阅类内部某种改变，用于观测

var demo = new Demo();
demo.CountChanged += (int x) => $"Count Changed to {x}".Dump();

demo.Count++;
demo.Count++;
demo.Count++;

class Demo
{
    int count;
    public int Count
    {
        get => count;
        set 
        {
            count = value;
            CountChanged?.Invoke(count);
        }
    }
    public event Action<int> CountChanged;
}

标准.net事件模式

//ObservableCollection
//当集合发生变化时自动通知（添加、删除、清空、重置）
var collection = new ObservableCollection<int>();

// sender: 触发事件的集合（就是 collection 本身）
// e: NotifyCollectionChangedEventArgs 类型，包含变更详情
// 比如，e.Action可能为NotifyCollectionChangedAction.Add
collection.CollectionChanged += (sender, e) => "collection changed observed".Dump(); 
//见EventHandler

EventHandler

public delegate void EventHandler(object sender, Event
                                  Args e);

// 参数说明：
// sender: 谁触发了这个事件？（事件的发送者）
// e: 事件的相关数据（比如变更的内容）