MessageQueue e Async/Await

Question

Voglio solo ricevere il mio messaggio in un metodo asincrono! e il suo congelamento mia UI

public async void ProcessMessages() 
    { 
     MessageQueue MyMessageQueue = new MessageQueue(@".\private$\MyTransactionalQueue"); 
     MyMessageQueue.Formatter = new XmlMessageFormatter(new Type[] { typeof(string) }); 

     while (true) 
     { 
      MessageQueueTransaction MessageQueueTransaction = new MessageQueueTransaction(); 
      MessageQueueTransaction.Begin(); 

      ContainError = false; 
      ProcessPanel.SetWaiting(); 

      string Body = MyMessageQueue.Receive(MessageQueueTransaction).Body.ToString(); 

      //Do some process with body string. 

      MessageQueueTransaction.Commit(); 
     } 
    } 

sto solo chiamando il metodo come qualsiasi metodo regolare e le sue nos a lavorare! Questo codice funzionava quando stavo usando BackgroundWorkers invece di async/await

Idee?

Answer 1

Come scrive Stefano, asincrona non viene eseguito il codice in un thread. Fortunatamente, è possibile utilizzare TaskFactory.FromAsync con MessageQueue.BeginReceive /MessageQueue.EndReceive di ricevere messaggi in modo asincrono:

private async Task<Message> MyAsyncReceive() 
    { 
     MessageQueue queue=new MessageQueue(); 
     ... 
     var message=await Task.Factory.FromAsync<Message>(
          queue.BeginReceive(), 
          queue.EndReceive); 

     return message; 

    } 

Si dovrebbe notare però che non c'è una versione di BeginReceive che utilizza una transazione. Da documenti BeginReceive:

Non utilizzare la chiamata asincrona BeginReceive con le transazioni. Se si desidera eseguire un'operazione asincrona transazionale, chiamare BeginPeek e inserire la transazione e il metodo di ricezione (sincrono) all'interno del gestore eventi creato per l'operazione di visualizzazione.

Questo ha senso in quanto non vi è alcuna garanzia per quanto tempo è necessario attendere una risposta o quale thread gestirà la chiamata completata.

di utilizzare le transazioni si potrebbe scrivere qualcosa di simile:

private async Task<Message> MyAsyncReceive() 
    { 
     var queue=new MessageQueue(); 

     var message=await Task.Factory.FromAsync<Message>(queue.BeginPeek(),queue.EndPeek); 

     using (var tx = new MessageQueueTransaction()) 
     { 
      tx.Begin(); 

      //Someone may have taken the last message, don't wait forever 
      //Use a smaller timeout if the queue is local 
      message=queue.Receive(TimeSpan.FromSeconds(1), tx); 
      //Process the results inside a transaction 
      tx.Commit(); 
     } 
     return message; 
    } 

UPDATE

Come Rob ha sottolineato, il codice originale utilizzato il message tornato da Peek, che può aver cambiato tra Peek e Receive. In questo caso il secondo messaggio verrà perso.

C'è comunque una possibilità di blocco, se un altro client legge l'ultimo messaggio in coda. Per evitare ciò, Receive dovrebbe avere un piccolo timeout.

Answer 2

async does not run your code on a background thread. Il tuo codice sopra dovrebbe aver causato un avvertimento del compilatore che ti dice che il tuo metodo verrà eseguito in modo sincrono.

Se si desidera eseguire un metodo su un thread in background, utilizzare TaskEx.Run:

public void ProcessMessages() 
{ 
    ... 
} 

TaskEx.Run(() => ProcessMessages());