c# - 异步操作中的异步操作

我的多线程知识还很初级，因此，这里的一些指针将非常有用。我有一个接口(interface)IOperationInvoker(来自WCF)，具有以下方法:

IAsyncResult InvokeBegin(object instance, object[] inputs, AsyncCallback callback, object state)
object InvokeEnd(object instance, out object[] outputs, IAsyncResult result)

给定此接口(interface)的具体实现，我需要实现相同的接口(interface)，同时在单独的线程中调用基础实现。 (如果您想知道为什么，具体实现会调用需要处于不同单元状态的旧版COM对象)。

此刻，我正在做这样的事情:

public StaOperationSyncInvoker : IOperationInvoker {
   IOperationInvoker _innerInvoker;
   public StaOperationSyncInvoker(IOperationInvoker invoker) {
       this._innerInvoker = invoker;
   }


    public IAsyncResult InvokeBegin(object instance, object[] inputs, AsyncCallback callback, object state)
    {
        Thread t = new Thread(BeginInvokeDelegate);
        InvokeDelegateArgs ida = new InvokeDelegateArgs(_innerInvoker, instance, inputs, callback, state);
        t.SetApartmentState(ApartmentState.STA);
        t.Start(ida);
        // would do t.Join() if doing syncronously
        // how to wait to get IAsyncResult?
        return ida.AsyncResult;
    }

    public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result)
    {
        // how to call invoke end on the
        // thread? could we have wrapped IAsyncResult
        // to get a reference here?
        return null;
    }

    private class InvokeDelegateArgs {
        public InvokeDelegateArgs(IOperationInvoker invoker, object instance, object[] inputs, AsyncCallback callback, object state)
        {
            this.Invoker = invoker;
            this.Instance = instance;
            this.Inputs = inputs;
            this.Callback = callback;
            this.State = state;
        }

        public IOperationInvoker Invoker { get; private set; }
        public object Instance { get; private set; }
        public AsyncCallback Callback { get; private set; }
        public IAsyncResult AsyncResult { get; set; }
        public Object[] Inputs { get; private set; }
        public Object State { get; private set; }
    }
    private static void BeginInvokeDelegate(object data)
    {
        InvokeDelegateArgs ida = (InvokeDelegateArgs)data;
        ida.AsyncResult = ida.Invoker.InvokeBegin(ida.Instance, ida.Inputs, ida.Callback, ida.State);
    }
}

我以为我需要用自己的包装回传的AsyncResult，这样我可以回到我们假脱机的线程中……但是说实话，我有点不尽如人意了。有指针吗？

非常感谢，

詹姆士

最佳答案

异步实现同步方法的最简单方法是将其放入委托(delegate)中，并在生成的委托(delegate)上使用BeginInvoke和EndInvoke方法。这将在线程池线程上运行同步方法，并且BeginInvoke将返回IAsyncResult实现，因此您不必实现它的全部。但是，您确实需要将一些额外的数据走私到IAsyncResult返回的IOperationInvoker.InvokeEnd中。通过创建将所有内容委派给内部IAsyncResult的IAsyncResult实现，您可以轻松地做到这一点，但是有一个额外的字段包含委托(delegate)，因此，当IAsyncResult实例传递给InvokeEnd时，您可以访问该委托(delegate)以在其上调用EndInvoke 。

但是，仔细阅读您的问题后，我发现您需要使用带有COM设置等的显式线程。

您需要做的是正确实现IAsyncResult。由于IAsyncResult将包含同步所需的所有位，因此几乎所有内容都随之而来。

这是IAsyncResult的非常简单但效率不高的实现。它封装了所有基本功能:传递参数，同步事件，回调实现，从异步任务传播异常并返回结果。

using System;
using System.Threading;

class MyAsyncResult : IAsyncResult
{
    object _state;
    object _lock = new object();
    ManualResetEvent _doneEvent = new ManualResetEvent(false);
    AsyncCallback _callback;
    Exception _ex;
    bool _done;
    int _result;
    int _x;

    public MyAsyncResult(int x, AsyncCallback callback, object state)
    {
        _callback = callback;
        _state = state;
        _x = x; // arbitrary argument(s)
    }

    public int X { get { return _x; } }

    public void SignalDone(int result)
    {
        lock (_lock)
        {
            _result = result;
            _done = true;
            _doneEvent.Set();
        }
        // never invoke any delegate while holding a lock
        if (_callback != null)
            _callback(this);
    }

    public void SignalException(Exception ex)
    {
        lock (_lock)
        {
            _ex = ex;
            _done = true;
            _doneEvent.Set();
        }
        if (_callback != null)
            _callback(this);
    }

    public object AsyncState
    {
        get { return _state; }
    }

    public WaitHandle AsyncWaitHandle
    {
        get { return _doneEvent; }
    }

    public bool CompletedSynchronously
    {
        get { return false; }
    }

    public int Result
    {
        // lock (or volatile, complex to explain) needed
        // for memory model problems.
        get
        {
            lock (_lock)
            {
                if (_ex != null)
                    throw _ex;
                return _result;
            }
        }
    }

    public bool IsCompleted
    {
        get { lock (_lock) return _done; }
    }
}

class Program
{
    static void MyTask(object param)
    {
        MyAsyncResult ar = (MyAsyncResult) param;
        try
        {
            int x = ar.X;
            Thread.Sleep(1000); // simulate lengthy work
            ar.SignalDone(x * 2); // demo work = double X
        }
        catch (Exception ex)
        {
            ar.SignalException(ex);
        }
    }

    static IAsyncResult Begin(int x, AsyncCallback callback, object state)
    {
        Thread th = new Thread(MyTask);
        MyAsyncResult ar = new MyAsyncResult(x, callback, state);
        th.Start(ar);
        return ar;
    }

    static int End(IAsyncResult ar)
    {
        MyAsyncResult mar = (MyAsyncResult) ar;
        mar.AsyncWaitHandle.WaitOne();
        return mar.Result; // will throw exception if one
                           // occurred in background task
    }

    static void Main(string[] args)
    {
        // demo calling code
        // we don't need state or callback for demo
        IAsyncResult ar = Begin(42, null, null);
        int result = End(ar);
        Console.WriteLine(result);
        Console.ReadLine();
    }
}

为了确保正确性，客户端代码无法看到IAsyncResult实现非常重要，否则客户端代码可能会不适本地访问SignalException之类的方法或过早读取Result。如果不需要，可以通过不构造WaitHandle实现(在示例中为ManualResetEvent)来提高类的效率，但这很难使100％正确。另外，可以和应该在Thread实现中处理ManualResetEvent和End，应该对所有实现IDisposable的对象进行处理。显然，End应该检查以确保它已经实现了正确的类，以获取比强制转换异常更好的异常。我忽略了这些和其他细节，因为它们模糊了异步实现的基 native 制。

关于c# - 异步操作中的异步操作，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/763417/