C#: utilizzo di RegisterWaitForSingleObject se l'operazione viene completata per la prima volta

Question

Sto eseguendo alcuni I/O di rete asincroni utilizzando i metodi di stile Begin/End. (In realtà è una query su Azure Table Storage, ma non penso che importi.) Ho implementato un timeout lato client usando lo ThreadPool.RegisterWaitForSingleObject(). Funziona bene per quanto posso dire.

Perché ThreadPool.RegisterWaitForSingleObject() prende un WaitHandle come argomento, devo iniziare l'operazione di I/O, quindi eseguire ThreadPool.RegisterWaitForSingleObject(). Sembra che questo introduca la possibilità che l'I/O completi prima ancora di registrare l'attesa.

Un esempio di codice semplificato:

private void RunQuery(QueryState queryState) 
{ 
    //Start I/O operation 
    IAsyncResult asyncResult = queryState.Query.BeginExecuteSegmented(NoopAsyncCallback, queryState); 

    //What if the I/O operation completes here? 

    queryState.TimeoutWaitHandle = ThreadPool.RegisterWaitForSingleObject(asyncResult.AsyncWaitHandle, QuerySegmentCompleted, asyncResult, queryTimeout, true); 
} 

private void QuerySegmentCompleted(object opState, bool timedOut){ 
    IAsyncResult asyncResult = opState as IAsyncResult; 
    QueryState state = asyncResult.AsyncState as QueryState; 

    //If the I/O completed quickly, could TimeoutWaitHandle could be null here? 
    //If so, what do I do about that? 
    state.TimeoutWaitHandle.Unregister(asyncResult.AsyncWaitHandle); 
} 

Qual è il modo corretto di gestire questa situazione? Devo ancora preoccuparmi di Unregister() di AsyncWaitHandle? Se è così, c'è un modo abbastanza semplice per aspettare che venga impostato?

Answer 1

Sì, tu e tutti gli altri hanno questo problema. E non importa se l'IO completato in modo sincrono o meno. C'è ancora una corsa tra il callback e il compito. Microsoft avrebbe dovuto fornire automaticamente la funzione di callback allo RegisteredWaitHandle. Questo avrebbe risolto tutto. Oh bene, il senno di poi è sempre 20-20 come si suol dire.

Quello che devi fare è continuare a leggere la variabile RegisteredWaitHandle fino a quando non è più nullo. Va bene farlo in un circuito chiuso perché la gara è abbastanza sottile che il circuito non girerà molte volte.

private void RunQuery(QueryState queryState) 
{ 
    // Start the operation. 
    var asyncResult = queryState.Query.BeginExecuteSegmented(NoopAsyncCallback, queryState); 

    // Register a callback. 
    RegisteredWaitHandle shared = null; 
    RegisteredWaitHandle produced = ThreadPool.RegisterWaitForSingleObject(asyncResult.AsyncWaitHandle, 
    (state, timedout) => 
    { 
     var asyncResult = opState as IAsyncResult; 
     var state = asyncResult.AsyncState as QueryState; 
     while (true) 
     { 
     // Keep reading until the value is no longer null. 
     RegisteredWaitHandle consumed = Interlocked.CompareExchange(ref shared, null, null); 
     if (consumed != null) 
     { 
      consumed.Unregister(asyncResult.AsyncWaitHandle); 
      break; 
     } 
     } 
    }, asyncResult, queryTimeout, true); 

    // Publish the RegisteredWaitHandle so that the callback can see it. 
    Interlocked.CompareExchange(ref shared, produced, null); 
} 

Answer 2

Non è necessario annullare la registrazione se l'I/O è stato completato prima del timeout poiché era il completamento che ha segnalato la richiamata. Infatti, leggendo i documenti del metodo Unregister, sembra del tutto inutile chiamarlo mentre esegui una sola volta e non stai annullando la registrazione in un metodo non correlato.

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

Se un metodo callback è in corso quando Deregistra esegue, waitObject non viene segnalata finché il metodo callback completa. In particolare, se un metodo di callback esegue l'annullamento della registrazione, waitObject non viene segnalato fino al completamento del metodo di callback.