Asynchronous XmlReader in .NET?

Question

C'è un modo per accedere a XmlReader in modo asincrono? L'xml sta uscendo dalla rete da molti client diversi come in XMPP; è un flusso costante di tag <action>...</action>.

Quello che voglio è poter utilizzare un'interfaccia BeginRead/EndRead-like. La soluzione migliore che ho trovato è quella di eseguire una lettura asincrona per 0 byte sul flusso di rete sottostante, quindi quando arrivano alcuni dati, chiama Read su XmlReader- questo tuttavia bloccherà fino a tutti i dati dal nodo diventa disponibile. Tale soluzione si presenta più o meno come questo

private Stream syncstream; 
private NetworkStream ns; 
private XmlReader reader; 

//this code runs first 
public void Init() 
{ 
    syncstream = Stream.Synchronized(ns); 
    reader = XmlReader.Create(syncstream); 
    byte[] x = new byte[1]; 
    syncstream.BeginRead(x, 0, 0, new AsynchronousCallback(ReadCallback), null); 
} 

private void ReadCallback(IAsyncResult ar) 
{ 
    syncstream.EndRead(ar); 
    reader.Read(); //this will block for a while, until the entire node is available 
    //do soemthing to the xml node 
    byte[] x = new byte[1]; 
    syncstream.BeginRead(x, 0, 0, new AsynchronousCallback(ReadCallback), null); 
} 

EDIT: Questo è un possibile algoritmo per lavorare fuori se una stringa contiene un nodo XML completo?

Func<string, bool> nodeChecker = currentBuffer => 
       { 
        //if there is nothing, definetly no tag 
        if (currentBuffer == "") return false; 
        //if we have <![CDATA[ and not ]]>, hold on, else pass it on 
        if (currentBuffer.Contains("<![CDATA[") && !currentBuffer.Contains("]]>")) return false; 
        if (currentBuffer.Contains("<![CDATA[") && currentBuffer.Contains("]]>")) return true; 
        //these tag-related things will also catch <? ?> processing instructions 
        //if there is a < but no >, we still have an open tag 
        if (currentBuffer.Contains("<") && !currentBuffer.Contains(">")) return false; 
       //if there is a <...>, we have a complete element. 
       //>...< will never happen because we will pass it on to the parser when we get to > 
       if (currentBuffer.Contains("<") && currentBuffer.Contains(">")) return true; 
       //if there is no < >, we have a complete text node 
       if (!currentBuffer.Contains("<") && !currentBuffer.Contains(">")) return true; 
       //> and no < will never happen, we will pass it on to the parser when we get to > 
       //by default, don't block 
       return false; 
      }; 

Answer 1

buffer XmlReader in blocchi da 4 KB, se ricordo da quando ho guardato a questo un paio di anni fa. Puoi tamponare i tuoi dati in entrata a 4kB (ick!), O usare un parser migliore. Ho fissato questo porting di James Clark XP (Java) per C# come parte di Jabber-Net, qui:

http://code.google.com/p/jabber-net/source/browse/#svn/trunk/xpnet

E 'LGPL, gestisce solo UTF8, non è confezionato per l'uso, e non ha quasi documentazione, quindi non lo consiglierei di usarlo. :)

Answer 2

Questo è veramente difficile, perché XmlReader non fornisce alcuna interfaccia asincrona.

Non sono sicuro di quanto si comporti in modo asincrono lo BeginRead quando si chiede di leggere 0 byte: potrebbe anche richiamare immediatamente la richiamata e quindi bloccare quando si chiama Read. Potrebbe essere la stessa cosa di chiamare direttamente Read e quindi programmare il prossimo Read in un pool di thread, ad esempio utilizzando QueueWorkItem.

Potrebbe essere preferibile utilizzare BeginRead sul flusso di rete per leggere i dati, ad esempio in blocchi da 10 KB (mentre il sistema attende i dati, non si bloccherebbe alcun thread). Quando si riceve un chunk, lo si copierà in alcuni locali MemoryStream e il proprio XmlReader leggerà i dati da questo MemoryStream.

Questo ha comunque un problema: dopo aver copiato 10kB di dati e chiamato Read diverse volte, l'ultima chiamata si bloccherebbe. Quindi probabilmente dovrai copiare blocchi di dati più piccoli per sbloccare la chiamata in attesa a Read. Una volta fatto, è possibile iniziare nuovamente una nuova chiamata BeginRead per leggere una porzione più ampia di dati in modo asincrono.

Onestamente, questo sembra piuttosto complicato, quindi sono abbastanza interessato se qualcuno ha una risposta migliore. Tuttavia, ti dà almeno alcune operazioni asincrone garantite che richiedono del tempo e non bloccano alcun thread nel frattempo (che è l'obiettivo essenziale della programmazione asincrona).

(Nota a margine: Si potrebbe provare a utilizzare F# asynchronous workflows a scrivere questo, perché fanno sì che il codice asincrono molto più semplice La tecnica che ho descritto sarà difficile anche in F # però.)

Answer 3

La cosa più facile da fare è basta metterlo su un altro filo, forse un ThreadPool a seconda di quanto a lungo rimane attivo. (Non utilizzare thread thread di thread per attività veramente di lunga durata).

Answer 4

Stai cercando qualcosa come il metodo XamlReader.LoadAsync?

Un'operazione carico XAML asincrona inizialmente restituire un oggetto che è puramente l'oggetto principale. In modo asincrono, l'analisi XAML quindi continua e qualsiasi oggetto figlio è inserito nella radice.

Answer 5

Sembra che DOT NET 4.5 abbia una proprietà bool Async su XmlReader, che non è presente in 3.5. Forse funzionerà per te?

Answer 6

XmlReader in .NET 4.5 ha async versioni della maggior parte dei metodi che coinvolgono IO.

Controllare il codice di esempio here.