Il modo migliore per scrivere DataTable da un servizio Web in XML?

Question

Sto cercando di ridefinire un codice di esecuzione lenta che scrive XML utilizzando cicli nidificati di più datatables. Ho letto che usare linq per scrivere l'xml sarebbe più veloce. Non sono esperto di linq, quindi speravo di ottenere un aiuto qui.

Alcune cose che ho bisogno di menzionare è che l'attuale architettura utilizza un webservice che restituisce i dati a noi in DataTable. Quindi passiamo attraverso i datatables (iterativamente), e ce ne sono diversi che risultano diversi loop annidati.

esempio:

dt1 = Webservice.getStuff(); 

for each (datarow r1 in dt1.Rows) { 

    dt2 = Webservice.getMoreStuff(r1[col1], r1[col2]); 
    // write out some xml 

    for each (datarow r2 in dt2.Rows) { 

     dt3 = Webservice.getEvenMoreStuff(r2[col1], r2[col2]); 
     // write out more xml 

     for each (datarow r3 in dt3.Rows) { 
      // write out more xml 
     } 

    } 
} 

Come si può vedere, per ovvie ragioni, questo è terribilmente lento. C'è un modo per accelerare usando linq? Cosa vorresti suggerire ragazzi come un approccio più efficiente per refactoring questo? Mi dispiace se i dettagli sono vaghi ...

Apprezzo tutto l'aiuto chiunque potrebbe offrire.

Answer 1

Scrivere l'XML non è ciò che sta rallentando in questo caso. Tale velocità dovrebbe essere trascurabile rispetto al tempo impiegato per effettuare tutte le chiamate al servizio web.

Invece di concentrarsi sulla scrittura dell'XML, proverei a capire come comprimere il numero di chiamate al servizio Web in modo da poter ottenere tutti i dati contemporaneamente anziché effettuare chiamate annidate in questo modo.

Answer 2

Se si desidera utilizzare Linq2Xml sono necessari anche Linq2Dataset.

In questo modo è possibile modificare la nidificato per i loop a una query LINQ e selezionare in XML.

mi aspetto che l'utilizzo di un XmlWriter potrebbe essere più veloce, però, e sarà certamente utilizzare meno memoria. Ma sarà un po 'più di lavoro da scrivere.

Answer 3

Ho paura che non ci sia cura per il vostro bisogno. Perché sono abbastanza sicuro che ciò che rende questo metodo lento non è come si scrive xml ma come si acquisiscono i dati. Se ci fosse qualche improvvisazione nello scrivere xml, non sarebbe in una proporzione notevole. Ti suggerisco di rivedere il modo in cui acquisisci i dati. Cerca di minimizzare il numero di chiamate WebService.

Answer 4

suona come è necessario al profilo la vostra applicazione prima di tutto - forse una prova gratuita di ANTS o simili lavorerà per voi.

Answer 5

utilizzando LINQ to XML e LINQ to set di dati è possibile creare il proprio xml come questo:

static void Main(string[] args) 
    { 

     DataTable t = getStuff("test"); 

     var xml = new XElement("Main", from row in t.AsEnumerable() 
       select new XElement("firstlevel", 
        new XAttribute("a", row["a"]), 
        new XAttribute("b", row["b"]), 
        from row2 in getStuff(row["a"].ToString()).AsEnumerable() 
        select new XElement("secondlevel", 
         new XAttribute("a", row2["a"]), 
         new XAttribute("b", row2["b"]), 
         from row3 in getStuff(row2["a"].ToString()).AsEnumerable() 
         select new XElement("thirdlevel", 
          new XElement("a", row3["a"]), 
          new XElement("b", row3["b"]))))); 

     Console.WriteLine(xml.ToString()); 


    } 

    private static DataTable getStuff(string s) 
    { 
     Random r=new Random(s.GetHashCode()); 
     DataTable t = new DataTable(); 
     t.Columns.Add("a"); 
     t.Columns.Add("b"); 
     for (int i = 0; i < 2; i++) 
     { 
      t.Rows.Add (r.Next().ToString(), r.Next().ToString()); 
     } 
     return t; 
    } 

Answer 6

È necessario re fattore la soluzione un po 'per sbarazzarsi di tutto ciò che in loop WS chiama. Questo è un serio peggioramento delle prestazioni.

Answer 7

Non si dice come si scrive l'XML o dove si scrive l'XML.

Se si sta scrivendo su una stringa. Smettila e scrivi un flusso.

Se si sta scrivendo su una stringa bufferizzata, osservare la dimensione del buffer. Se si sta scrivendo da una pagina o gestore ASP.NET, chiamare Response.Flush() a intervalli regolari.

C'è un equilibrio qui, poiché scrivere su un buffer è quasi sempre più veloce di scrivere su uno stream.Tuttavia, la scrittura su un buffer di ridimensionamento automatico diventerà più lenta quanto più deve ridimensionarsi. Inoltre, qualunque sia l'elaborazione dell'XML non può iniziare ad agire finché non inizia a riceverne alcuni, cosa che non succederà fino a dopo il primo flush.

In questo caso è possibile migliorare, sebbene le chiamate al servizio Web superino probabilmente i guadagni possibili. Forse questo può anche essere migliorato, se si riscrive l'analisi della risposta del webservice in modo che sia yields elementi come vengono analizzati, il che significa che è possibile avviare l'elaborazione della risposta prima che venga ricevuta l'intera risposta.