c# - 编写一个必须等​​待事件回调的函数

Question

问题

考虑以下代码:

class A
{
    private int _workId;

    public void DoWork()
    {
        _workId = new Random().Next(100);
        Console.WriteLine("Starting a long process ID: " + _workId);
        LongProcess longProcess = new LongProcess();
        longProcess.StartWork();
        longProcess.OnWorkMiddle += OnLongProcessWorkMiddle;
        Console.WriteLine("At end of long process: " + _workId);
        longProcess.OnWorkMiddle -= OnLongProcessWorkMiddle;
    }

    private void OnLongProcessWorkMiddle(object sender, EventArgs e)
    {
        Console.WriteLine("In middle of long process: " + _workId);
    }
}

由于以下几个原因，以下代码在我看来是有问题的:

1. 有代码分离，按逻辑应该组合在一起 - 我希望 Console.WriteLine("In middle of long process: " + _workId);出现在 Console.WriteLine("At end of long process: " + _workId); 旁边, 然而，它们都出现在不同的函数中。
2. _workId无论如何，应该是 DoWork 中的一个函数，但是，我不得不将它设为一个字段函数，以便能够从回调内部访问该信息。每个附加参数或返回值也将成为字段成员。

替代解决方案

有一些解决方案可以减少此代码中的问题数量:

将函数及其回调封装在不同的类中

我在上面描述的问题之一是字段成员不一定与整个所有者类相关，而是特定于函数 DoWork 及其回调。通过将函数封装在它自己的类中，我们消除了不必要的困惑并将它分组在它自己的逻辑组中。缺点是它需要从本来应该是一个函数的东西中创建一个类。它也没有解决问题 #1。

使用匿名委托(delegate)保持在一个函数中

我们可以这样重写代码:

public void DoWork()
{
    var workId = new Random().Next(100);

    EventHandler onLongProcessWorkMiddle = delegate { Console.WriteLine("In middle of long process: " + workId); };

    Console.WriteLine("Starting a long process ID: " + workId);
    LongProcess longProcess = new LongProcess();
    longProcess.StartWork();
    longProcess.OnWorkMiddle += onLongProcessWorkMiddle;
    Console.WriteLine("At end of long process: " + workId);
    longProcess.OnWorkMiddle -= onLongProcessWorkMiddle;
}

现在我们不再需要任何字段成员，我们可以将所有内容很好地保存在一个函数中。然而，在可读性方面，我发现代码相当缺乏，因为稍后执行的代码(或者更确切地说是它的委托(delegate))出现在顶部。

使用半通用帮助类

在这个解决方案中，我编写了一个半通用的帮助器类来同步执行。它允许我以下列方式编写代码:

public void DoWork()
{
    var workId = new Random().Next(100);

    LongProcess longProcess = new LongProcess();

    var syncr = new EventSyncr();
    syncr.Sync(
        delegate { longProcess.OnWorkMiddle += syncr.EventCallback; },
        delegate { longProcess.StartWork(); },
        delegate { Console.WriteLine("In middle of long process: " + workId); },
        delegate { longProcess.OnWorkMiddle -= syncr.EventCallback; });

    Console.WriteLine("At end of long process: " + workId);
}

下面是辅助类的代码:

/// <summary>
/// Used to synchronize code that waits for a callback from a function.
/// </summary>
class EventSyncr
{
    readonly AutoResetEvent _eventCallbackEvent = new AutoResetEvent(false);
    private Action _actionAtEvent;

    /// <summary>
    /// Executes the syncing process. This function is blocked until the event is called back (once), then it executes the 'actionAtEvent' segment and
    /// after unsubscription, exists.
    /// </summary>
    /// <param name="eventSubscription">The passed delegate must subscribe the event to EventSyncr.EventCallback.</param>
    /// <param name="eventCausingAction">The event causing action.</param>
    /// <param name="actionAtEvent">The action at event.</param>
    /// <param name="eventUnsubscription">Unsubscribe the event that was subscribed in the first parameter</param>
    public void Sync(Action eventSubscription, Action eventCausingAction, Action actionAtEvent, Action eventUnsubscription)
    {
        _actionAtEvent = actionAtEvent;

        try
        {
            eventSubscription();
            eventCausingAction();
            _eventCallbackEvent.WaitOne();
        }
        finally
        {
            eventUnsubscription();
        }
    }

    public void EventCallback(object sender, EventArgs e)
    {
        try
        {
            _actionAtEvent();
        }
        finally
        {
            _eventCallbackEvent.Set();
        }
    }
}

虽然有点冗长，但在我看来它确实解决了我上面提出的所有问题:

代码以其将要执行的方式出现，按其逻辑顺序显示，所有附加属性都是自包含的。

问题

我很好奇您对这个问题的看法以及可能的解决方案。哪个看起来最好？有没有更好的方法来解决这个问题？

我知道在 C# 5 中，await 函数将提供更好的解决方案，但我们还没有做到这一点 :(。

谢谢!

Answer 1

你的 EventSyncr 类太奇怪了，你应该为此获得额外奖励，开个玩笑 ;)

但实际上，您只需创建一个 AutoResetEvent 并在代码末尾使用 WaitHandle.WaitAll 等待它。

在您的异步方法结束时，您必须发出 AutoResetEvent 信号，并且您的主线程知道您的异步过程刚刚完成。

public void DoWork()
{
    var workId = new Random().Next(100);

    Console.WriteLine("Starting a long process ID: " + workId);
    LongProcess longProcess = new LongProcess();
    longProcess.StartWork();
    longProcess.OnWorkMiddle += ()=>{ Console.WriteLine("In middle of long process: " + workId);
    longProcess.OnWorkEnd += ()=>{ 
       Console.WriteLine("At the end of a long process");
       autoEvent.Set();
    };

    WaitHandle.WaitAll(new []{longProcess.autoEvent});
}