Question

长话短说我有两个名为FirstBool和SecondBool的布尔变量。我有一个程序，它使用两个委托异步运行两个方法。我正在使用Console.ReadLine()在子线程运行时保持父线程处于活动状态。

第一个方法完成后，FirstBool设置为true。第二个方法完成后，SecondBool设置为true。

长话短说，我想将我的事件定义为“FirstBool和SecondBool都是真的”，并在此时关闭我的程序。我能看到的唯一选择是轮询两个布尔值，直到它们都为真，然后关闭程序，并且轮询很糟糕。

我的代码如下：

class Program
{
    private delegate void MyDelegate();

    private static bool FirstBool { get; set; }
    private static bool SecondBool { get; set; } 

    static void Main(string[] args)
    {
        FirstBool = false;
        SecondBool = false;

        MyDelegate firstDelegate = new MyDelegate(FirstMethod);
        MyDelegate secondDelegate = new MyDelegate(SecondMethod);

        AsyncCallback myCallback = new AsyncCallback(CallbackMethod);

        firstDelegate.BeginInvoke(myCallback, "Zip");
        secondDelegate.BeginInvoke(myCallback, "Line");

        Console.ReadLine();
    }

    private static void CallbackMethod(IAsyncResult result)
    {
        switch (result.AsyncState.ToString())
        {
            case "Zip":
                FirstBool = true;
                break;
            case "Line":
                SecondBool = true;
                break;
        }

        Console.WriteLine("Callback Method");
    }

    private static void FirstMethod()
    {
        Console.WriteLine("First Method");
    }

    private static void SecondMethod()
    {
        Console.WriteLine("Second Method");
    }
}

所以，长话短说，如何创建一个定义为“FirstBool为真且SecondBool为真”的事件，并在此事件发生时运行方法？

由于

Answer 1

如果您可以访问.NET 4，那么您可以使用任务并行库轻松完成此任务：

var taskOne = Task.Factory.StartNew(() =>
   {
       // Do Stuff
   });

var taskTwo = Task.Factory.StartNew(() =>
   {
       // Do Other Stuff
   });

Task.WaitAll(taskOne, taskTwo);

// Quit

如果您使用的是旧版本的.NET，则只需调用EndInvoke方法等待异步调用完成：

 SomeDelegate x = SomeMethod;
 SomeDelegate y = SomeOtherMethod;

 var iar1 = x.BeginInvoke(null, null);
 var iar2 = y.BeginInvoke(null, null);

 // Program would still be executing here...

 x.EndInvoke(iar1);
 y.EndInvoke(iar2);

 // Quit

Answer 2

在每个布尔值的setter中，检查它们是否都是真的。如果是，您可以运行您的方法。

以下是您如何做到这一点的示例：

public static object syncLock = new object();

private static bool myFirstBool;
private static bool mySecondBool;
private static bool FirstBool {
    get { return myFirstBool; }
    set {
        lock (syncLock) {
            if (value && mySecondBool) {
                CallbackMethod(null);
            }
            myFirstBool = value;
        }
    }
}
private static bool SecondBool {
    get { return mySecondBool; }
    set {
        lock (syncLock) {
            if (value && myFirstBool) {
                CallbackMethod(null);
            }
            mySecondBool = value;
        }
    }
}

Answer 3

这是实现目标的一种非常困难且容易出错的方式。

看看这篇文章，它将以更安全和更好的方式帮助您完成您想要做的事情

http://msdn.microsoft.com/en-us/library/system.threading.eventwaithandle.aspx

Answer 4

对于特定的应用程序，我强烈建议在等待两个事件时使用System.Threading.ManualResetEvent或 - 等同步原语 - System.Threading.Semaphore。您将创建一个信号量变量，其初始计数为零，最大计数为2。您可以调用bool而不是设置Release()，而在主线程中等待信号量发出两次信号。

如果某一特定情况属实，我如何定义事件？

4 个答案: