WCF Async Deadlock?

Question

Qualcuno si è imbattuto in una situazione in cui una chiamata Waitany restituisce un indice di manubrio valido, ma i blocchi di chiamata proxy.end? Oppure ha qualche raccomandazione o come eseguire il migliore debug di questo - Trovato traccia, contatori delle prestazioni (per controllare le percentuali massime), registrazione ovunque

Lo scenario di prova: 2 asincroni. Le richieste stanno uscendo (c'è un po 'di più per la piena implementazione) e il 1 ° proxy. Ho controllato la traccia del WCF e non vedo nulla di particolarmente interessante. Si noti che si tratta di auto -interrogazione di un endpoint che esiste nello stesso processo e una macchina remota (= 2 richieste di asincroni)

Per quanto posso vedere, la chiamata sta attraversando dal lato dell'implementazione del servizio per entrambe le domande, ma si blocca solo sulla chiamata di fine successiva. Sembra funzionare con una sola chiamata, indipendentemente dal fatto che stia inviando la richiesta a una macchina remota o a se stessa; Quindi ha qualcosa a che fare con le domande multiple o qualche altro fattore che causa il blocco.

Ho provato diversi "ConcorrencyMode" e "InstanceContextMode", ma non sembra avere alcuna influenza sul risultato.

Ecco una versione ridotta del codice interno per analizzare l'elenco delle impugnature:

ValidationResults IValidationService.EndValidate()
    {
        var results = new ValidationResults();

        if (_asyncResults.RemainingWaitHandles == null)
        {
            results.ReturnCode = AsyncResultEnum.NoMoreRequests;
            return results;                
        }

        var waitArray = _asyncResults.RemainingWaitHandles.ToArray();
        if (waitArray.GetLength(0) > 0)
        {
            int handleIndex = WaitHandle.WaitAny(waitArray, _defaultTimeOut);
            if (handleIndex == WaitHandle.WaitTimeout)
            {
                // Timeout on signal for all handles occurred                    
                // Close proxies and return...
            }

            var asyncResult = _asyncResults.Results[handleIndex];



            results.Results = asyncResult.Proxy.EndServerValidateGroups(asyncResult.AsyncResult);

            asyncResult.Proxy.Close();
            _asyncResults.Results.RemoveAt(handleIndex);
            _asyncResults.RemainingWaitHandles.RemoveAt(handleIndex);

    results.ReturnCode = AsyncResultEnum.Success;
            return results;
        }

    results.ReturnCode = AsyncResultEnum.NoMoreRequests;
        return results;
    }

E il codice che chiama questo:

 validateResult = validationService.EndValidateSuppression();
 while (validateResult.ReturnCode == AsyncResultEnum.Success)
 {
       // Update progress step                        
       //duplexContextChannel.ValidateGroupCallback(progressInfo);

     validateResult = validationService.EndValidateSuppression();
 }

Ho commentato i callback sul nodo iniziale (FYI è in realtà una configurazione a 3 livelli, ma il problema è isolato a questo secondo livello che chiama il terzo livello: i callback vanno dal 2 ° livello al primo livello che è stato rimosso in questo test). Pensieri?

Answer 1

Attenersi alla soluzione che ho lasciato nel mio commento. Evita semplicemente di incatenare un callback a chiamate AYSNC che hanno destinazioni diverse (cioè proxy)