title: Asynchronous operations within an asynchronous operation
body: <p>My multi-threading knowledge is still pretty rudimentary, so would really appreciate some pointers here. I have an interface, IOperationInvoker (from WCF) which has the following methods:</p>
  
  <pre><code>IAsyncResult InvokeBegin(object instance, object[] inputs, AsyncCallback callback, object state)
  object InvokeEnd(object instance, out object[] outputs, IAsyncResult result)
  </code></pre>
  
  <p>Given a concrete implementation of this interface, I need to implement the same interface, whilst calling the underlying implementation in a seperate Thread. (in case you're wondering why, the concrete implmentation calls a legacy COM object which needs to be in a different apartment state).</p>
  
  <p>At the moment, I'm doing something like this:</p>
  
  <pre><code>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);
      }
  }
  </code></pre>
  
  <p>I'm thinking I need to wrap up the returned AsyncResult with my own, so I can get back to the thread we've spooled up... but honestly I'm a little out of my depth. Any pointers?</p>
  
  <p>Many thanks,</p>
  
  <p>James</p>