如何等到事件在c#中处理

Question

假设我们有这样的代码：

public class MyProcess
{
    private Process _process;
    public event EventHandler OnFinish;
    public MyProcess(string pathToExe)
    {
         _process = new Process();
         _process.StartInfo.FileName = pathToExe;
    }
    public int Start()
    {
         _process.Exited += _processExited;
         _process.Start();
         return _process.Id;
    }
    public void Stop()
    {
         _process.Stop();
    }
    private void _processExited(object sender, EventArgs e)
    {
         OnFinish?.Invoke();
    }
}

public class MyProgram
{
    private static int stoppedProcs = 0;

    public static void Main(string[] args)
    {
         var proc = new MyProcess("foo.exe");
         proc.OnFinish += proc_OnFinish;
         proc.Start();
         proc.Stop();
         //Wait here to display 1 instead of 0
         Console.WriteLine(stoppedProcs);
    }

    private static void proc_OnFinish(object sender, EventArgs e)
    {
         stoppedProcs++;
    }
}

我创建并启动进程。然后我想停止它并仅在处理完事件后继续。问题是我不会自己调用事件，因为它是由操作系统完成的。如何理解事件处理程序已完成？

Answer 1

假设您想同步等待（阻塞当前线程），只需通过您的类公开Process.WaitForExit 方法。

public void WaitForExit()
{
    _process.WaitForExit();
}

Answer 2

扩展提到 Task 和 await 东西的答案

如果您想将等待变成异步流，您可以将Exited 事件与TaskCompletionSource 结合起来，如下所示：

public static class ProcessExtension
{
    public static Task WaitForExitAsync(this Process proc, Action callback)
    {
        return new WaitForExitExt(proc, callback).WaitTask;
    }

    class WaitForExitExt
    {
        private TaskCompletionSource<int> _tcs;
        private Action _callback;

        public WaitForExitExt(Process proc, Action callback)
        {
            _callback = callback;
            proc.EnableRaisingEvents = true;

            _tcs = new TaskCompletionSource<int>();

            if (proc.HasExited)
            {
                _tcs.TrySetResult(proc.ExitCode);
            }
            else
            {
                proc.Exited += OnProcessExited;

                // Process already exited by the time the handler was attached.
                if (proc.HasExited)
                {
                    proc.Exited -= OnProcessExited;
                    _tcs.TrySetResult(proc.ExitCode);
                }
            }
        }

        public Task WaitTask => _tcs.Task;

        private void OnProcessExited(object sender, EventArgs e)
        {
            var proc = (Process)sender;
            proc.Exited -= OnProcessExited;

            _callback();

            _tcs.TrySetResult(proc.ExitCode);
        }
    }
}

上述扩展能够在进程退出后运行callback，并且保证在任务完成之前运行callback，因此您可以在代码中使用它：

var process = new Process();
process.StartInfo.FileName = "notepad.exe";
process.EnableRaisingEvents = true;
process.Start();

var task = process.WaitForExitAsync(() => Console.WriteLine("Exited"));
process.Kill();
await task;

Console.WriteLine("Task finished");

输出是：

Exited
Task finished

Answer 3

感谢大家回答我的问题。 通过@Fildor 建议使用ManualResetEvent，问题很容易解决

public class MyProgram
{
private static int stoppedProcs = 0;
private static ManualResetEvent mre = new ManualResetEvent(false);
public static void Main(string[] args)
{
     var proc = new MyProcess("foo.exe");
     proc.OnFinish += proc_OnFinish;
     proc.Start();
     proc.Stop();
     //Wait here to display 1 instead of 0
     mre.WaitOne();
     mre.Reset();
     Console.WriteLine(stoppedProcs);
}

private static void proc_OnFinish(object sender, EventArgs e)
{
     stoppedProcs++;
     mre.Set();
}
}