0

长话短说，我有两个布尔变量，分别称为 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是真的”的事件并在这个事件发生时运行一个方法？

谢谢

4

4 回答 4

3

如果您可以访问 .NET 4，那么您可以使用 Task Parallel Library 轻松完成此任务：

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
于 2012-04-20T17:09:40.810 回答
1

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

这是一个如何做到这一点的示例：

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;
        }
    }
}
于 2012-04-20T17:02:48.607 回答
1

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

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

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

于 2012-04-20T17:04:04.410 回答
0

For the specific application, I would stronly recommend using a synchronisation primitive like a System.Threading.ManualResetEvent or - as you wait for two events - a System.Threading.Semaphore. You would create a semaphore variable with an initial count of zero and a maximum count of two. Instead of setting a bool, you call Release() and in the main thread you wait for the semaphore being signaled twice.

于 2012-04-20T17:12:47.797 回答