Question

假设我有IAsynchronous接口支持两种执行某些操作的方法（“开始/结束”模式）：

IAsyncResult BeginOperation(AsyncCallback callback, object state)
EndOperation(IAsyncResult ar)

我还假设我有班级A : IAsynchronous和B : IAsynchronous。我必须实现Compound : IAsynchronous类。 Compound的操作是调用A的操作，等待它完成，然后调用B的操作，然后像往常一样调用回调。

问题是如何设计Compound类：

我应保留原始的state对象，并在Compound的操作完成时调用原始回调。因此，我不能简单地将它们传递给A.BeginOperation或B.BeginOperation。
此外，Compound.EndOperation应重新抛出A.EndOperation或B.EndOperation引发的任何异常。如果A.EndOperation抛出了异常，那么Compound的操作不应该调用B.EndOperation，因为复合操作已经失败。
如果不仅有2个内部操作，而是3个或更多，那该怎么办？有共同的方法吗？

为了澄清，请考虑以下示例。假设我们有Multiplier类支持以下方法：

IAsyncResult BeginMultiply(LargeNumber x, LargeNumber y, AsyncCallback callback, object state)
LargeNumber EndMultiply(IAsyncResult ar)

并且您想编写支持以下方法的ThreeMultiplier类：

IAsyncResult BeginMultiply(LargeNumber x, LargeNumber y, LargeNumber z, AsyncCallback callback, object state)
LargeNumber EndMultiply(IAsyncResult ar)

ThreeMultiplier类应使用Multiplier类来计算x * y * z。为此，首先计算x * y（通过Multiplier.Begin/EndMultiply），然后将结果乘以z。当然，Multiplier.EndMultiply会抛出SomeException，无法在任何步骤中计算x * y * z。

实施此方法的最佳（或好）方法是什么？有什么模式吗？

Answer 1

在编写新代码时，我会避免使用APM（异步编程模型：使用IAsyncResult和Begin *和End *）。

在Visual Studio 2010中引入了任务并行库（TPL），此时引入了任务异步模式（TAP）。此模式是支持VS 2012（C＃5）中新的async / await关键字的基础框架API的基础。您可以使用Task.FromAsync（）包装APM实现;但如果您正在编写新代码，那么使用Task / Task将是未来更好的选择。

使用TAP，您可以使用Task对象包装委托，该对象将异步执行委托。然后，您可以“继续”执行第一个委托完成时将运行的其他异步任务。例如，如果你有两个代表需要在另一个代表完成时运行，你可以这样做：

        Task.Factory.StartNew(() => MyMethod())
            .ContinueWith(() => MyOtherMethod());

您可以将其包装在一个方法中：

public void AsyncCompound(Action firstAcction, Action secondAction)
{
            Task.Factory.StartNew(firstAction)
                .ContinueWith(secondAction);
}

......定义IAsyncResult类并实现Begin和End方法的工作要少得多。

至于.NET 3.5--流行的模式是APM - 没有一致的“任务”类。有一些TPL实现可能会起作用，但我还没有使用它们。或者，您可以查看Reactive Extensions，因为它是实现异步操作的另一种方式 - 尽管基于事件。

APM可以快速获得详细信息，因此，我建议您尽可能使用代理。我还建议重新使用像http://msdn.microsoft.com/en-us/magazine/cc163467.aspx那样的IAsyncResult实现，例如：

public class Multiplier
{
    public LargeNumber Multiply(LargeNumber x, LargeNumber y)
    {
        return x * y;
    }

    public IAsyncResult BeginMultiply(LargeNumber x, LargeNumber y, AsyncCallback callback, object state)
    {
        AsyncResult<LargeNumber> ar = new AsyncResult<BigInteger>(callback, state);
        ThreadPool.QueueUserWorkItem(o =>
        {
            var asyncResult = (AsyncResult<LargeNumber>)o;
            try
            {
                var largeNumber = Multiply(x, y);
                asyncResult.SetAsCompleted(largeNumber, false);
            }
            catch (Exception e)
            {
                asyncResult.SetAsCompleted(e, false);
            }
        }, ar);
        return ar;
    }

    public LargeNumber EndMultiply(IAsyncResult asyncResult)
    {
        var ar = (AsyncResult<LargeNumber>)asyncResult;

        return ar.EndInvoke();
    }

    public IAsyncResult BeginMultiply(LargeNumber x, LargeNumber y, LargeNumber z, AsyncCallback callback, object state)
    {
        AsyncResult<LargeNumber> ar = new AsyncResult<LargeNumber>(callback, state);

        BeginMultiply(x, y, (asyncResult1) =>
        {
            var firstResult = EndMultiply(asyncResult1);
            BeginMultiply(firstResult, z, (asyncResult2) =>
            {
                var secondResult = EndMultiply(asyncResult2);
                ar.SetAsCompleted(secondResult, true);
            }, state);
        }, state);
        return ar;
    }
}

然后可以按如下方式使用它来异步计算一个值并返回当前线程：

var asyncResult = multiplier.BeginMultiply(x, y, z, ar => { }, null);
var result = multiplier.EndMultiply(asyncResult);

或者，您可以链接到其他代码以在后台线程上执行：

        multiplier.BeginMultiply(x, y, z, ar =>
                                          {
                                            var result = multiplier.EndMultiply(ar);
                                            /* TODO: something with result on this background thread */
                                          }, null);

...由您自己决定如何获得该结果以及如何与调用BeginMultiply的线程进行交互（如果有的话）。

Answer 2

如果你想实现一些结合异步操作的好方法 - 请查看Richter的Simplified APM With The AsyncEnumerator和next part，它允许使用yield创建的迭代器编写几乎连续的代码。

来自Wintellect网站的图书馆download。

使用示例 - Working with AsyncEnumerator

复合异步调用 - 如何？

2 个答案: