C# 用C语言对事件进行分组#

是否有任何现成的解决方案来分组事件

假设我有两个事件：A和B。 我希望在a和B被激发时执行方法M，它们不需要完全同时激发

比如： 组事件G在A和B都触发后触发。我只需要在组事件G中注册方法M

A可以发射多次，G只能在B发射后发射。同样的方式

我在找一个图书馆，里面有这些活动

编辑：示例

Events:
    A | B | G
1   F   0   0
2   0   F   F
3   0   F   0 
4   0   F   0 
5   0   F   0 
6   F   0   F
7   F   0   0
8   0   F   F
9   0   0   0 
10  F   F   F

F指火灾事件， 0它不是。

我认为这可能与您正在寻找的最接近。它提供了将事件转换为可观察事件的帮助，以及一种linq风格的语法，您可以使用它来组合这些可观察事件。

您可以使用它

查看（或Observable.FromEventPattern）方法，将标准.NET事件转换为Observable，然后使用将结果分组

下面是一个伪代码：

var observableA = Observable.FromEvent(yourEventA);
var observableB = Observable.FromEvent(yourEventB);

var observableG = observableA.CombineLatest(observableB, ...)

当两个事件都被触发时，将触发生成的可观察对象

编辑

CombineTest

生成具有最新结果的输出，而无需重置其状态。例如，如果A1被激发，那么B1被激发，G1被（A1+B1）激发，但是如果B2被激发，那么G2被（A1+B2）激发，依此类推

要准确地产生预期结果，您可以编写如下内容：

    private void SetupEvents()
    {
        var observableA = Observable.FromEventPattern((e) => btA.Click += e, (e) => btA.Click -= e);
        var observableB = Observable.FromEventPattern((e) => btB.Click += e, (e) => btB.Click -= e);

        EventPattern<object> lastA = null;
        EventPattern<object> lastB = null;
        var observableG = observableA.CombineLatest(observableB, (rA, rB) =>
        {
            if (lastA == rA || lastB == rB)
                return null;

            lastA = rA;
            lastB = rB;
            return new Tuple<EventPattern<object>, EventPattern<object>>(rA, rB);
        }).Where(p => p != null);

        observableG.Subscribe(r => Trace.WriteLine("A + B"));

        // or use ToEvent to generate another standard .NET event
        //observableG.ToEvent().OnNext += GEvent;
    }

    //void GEvent(System.Reactive.EventPattern<object> obj)
    //{
    //    Trace.WriteLine("A + B");
    //}

private void SetupEvents（）
{
var Observable EA=可观测。FromEventPattern（（e）=>btA.Click+=e，（e）=>btA.Click-=e）；
var Observable B=可观察。FromEventPattern（（e）=>btB.Click+=e，（e）=>btB.Click-=e）；
EventPattern lastA=null；
EventPattern lastB=null；
var observableG=observableA.CombineTest（observableB，（rA，rB）=>
{
if（lastA==rA | | lastB==rB）
返回null；
lastA=rA；
lastB=rB；
返回新元组（rA，rB）；
})。其中（p=>p！=null）；
Observable.Subscribe（r=>Trace.WriteLine（“A+B”）；
//或者使用ToEvent生成另一个标准.NET事件
//observableG.ToEvent（）.OnNext+=GEvent；
}
//void GEvent（System.Reactive.EventPattern obj）
//{
//Trace.WriteLine（“A+B”）；
//}

基本上，我检查最新的结果是否与当前的结果不同。

---

也许您的案例有一些本机RX扩展，但我找不到。

您可以自己编写这样的类。下面是一个（非常）简单的实现：

public class TwoEventGroup { private bool _eventAFired; private bool _eventBFired; public void EventAHandler() { _eventAFired = true; TestAndFire(); } public void EventBHandler() { _eventBFired = true; TestAndFire(); } private void TestAndFire() { if (_eventAFired && _eventBFired) { _eventAFired = false; _eventBFired = false; if (GroupEvent != null) GroupEvent(); } } public event Action GroupEvent; } 公共类TwoEventGroup { 私人住宅事件发生； 私人楼宇事件引发； public void EventAHandler（） { _eventAFired=true； TestAndFire（）； } public void EventBHandler（） { _eventBFired=true； TestAndFire（）； } 私有无效TestAndFire（） { 如果（_eventAFired&&u eventAFired） { _eventAFired=false； _eventBFired=false； if（GroupEvent！=null） GroupEvent（）； } } 公共事件行动小组活动； } 这只是一个概念性的实现，您可能希望将事件委托作为一个泛型，将其扩展到n个事件，而不是两个事件，（可能）处理事件触发之间的超时，考虑如何扩展此类（如果有的话），等等

---

@spender对Rx的建议是值得的（+1），但该库面向异步事件，并且有一个稍微陡峭的学习曲线。如果您只想对已知事件或相同类型的事件进行简单的分组，而不是完全通用的事件，这可能会有些过分。

不知道类似的事情，但是如果您说a、a、a、b、b被激发，在这种情况下，g应该被触发多少次？或者您是否在代码中保证A和B对于给定实例只触发一次？更多的细节确实会有帮助。