opération de base de données via Threadpool ou Asyn programmation

Question

i ont la base de données avec plus grand nombre d'enregistrements. (Valeurs de base de données sont mises à jour via un webservice)

Chaque enregistrement/ligne est de type (id, XMLFileName, fonctionnement, paramètres, operationId, statut) ie. nous avons effectuer l'opération comme spécifié par'operation 'sur un fichier xml spécifié par "nomfichierxml" avec les paramètres d'opération spécifiés par "paramètres" .. partie d'état est "intially" libre comme est mis à jour comme lorsque reqd.

-je faire entre eux (par ligne) en utilisant l'opération Threads..ie un thread par « identifiant » nombre de entries.as tant qu'il existe des rangées « id » dans db aller chercher et exécuter « opération »

comment puis-je le faire efficacement avec un maximum de parallélisme et/ou de concurrence.

Y a-t-il un meilleur moyen? Quels sont les threads Threadpool ou personnalisés les mieux adaptés ou la programmation asyn?

Modifier Ajouté: Voici le code pseudo i essayé

string operationId=null; 

while(operationId = DBWorker.getNextFreeOperationId()) 
//how do i check this?another query??untill there are operations with status "Free" 
//,keep selecting operationids 
//note db is updating asynchronously.  
{ 
    //retrieve all rows with operationid=operationId eg:800 . 1 thread/qid???? and 
    // status="free" ... 
//there are multiple operations with same operationIds 

    DataRowCollection dbRows=DBWorker.retrieveQueuedEntries(operationId); 
    MyWorkItem workItem = new DBWorker.MyWorkItem(); 
    workItem.DataRows = dbRows; 
    workItem.Event = new AutoResetEvent(false); 
//MyWorkItem.DoWork will do the necessary "Operation" 
ThreadPool.QueueUserWorkItem(new WaitCallback(workItem.DoWork),workItem); 
} 
-------------- 
MyWorkItem.DoWork(obj x){ 
//for brevity 
for each DataRow row in this.DataRows 
    { 
    performOperation(row);//use row["operation"] .. 
    } 
--------------- 
bool performOperation(DataRow row) 
{ 
    string operation = (string)row["operation"];//retrieve other similarly 
    switch(operation) 
    { 
    case Operations.Add: //call Add operation .. 
    ... 
    } 
} 
------------ 

code ci-dessus est using.net2.0 .. ne marche pas atteindre multithreading .. scénario peut être la base de données est mise à jour d'une extrémité de manière asynchrone, alors que le code ci-dessus sera exécuté en tant que service Windows en même temps.

thx
Amit

Answer 1

Si vous ne l'utilisez .net 4.0 - Utilisation ThreadPool je créerais une fonction qui recevra la ligne (événement mieux si vous convertissez les lignes à typer objets DAL) il doit traiter, et faire ce qu'il doit faire avec elle - quelque chose comme

using System; 
using System.Threading; 

namespace SmallConsoleAppForTests 
{ 
class Program 
{ 

    private static AutoResetEvent[] events; 

    static void Main(string[] args) 
    { 

     int dataLength = 3; 
     // creating array of AutoResetEvent for signalling that the processing is done 
     AutoResetEvent[] events = new AutoResetEvent[dataLength]; 

     // Initializing the AutoResetEvent array to "not-set" values; 
     for (int i = 0; i < dataLength; i++) 
      events[i] = new AutoResetEvent(false); 

     //Processing the data 
     for (int i = 0; i < dataLength; i++) 
     { 
      var data = new MyWorkItem { Event = events[i], Data = new MyDataClass() }; 

      ThreadPool.QueueUserWorkItem(x => 
      { 
       var workItem = (MyWorkItem)x; 
       try 
       { 
        // process the data 

       } 
       catch (Exception e) 
       { 
        //exception handling 
       } 
       finally 
       { 
        workItem.Event.Set(); 
       } 
      }, data); 
     } 

     //Wait untill all the threads finish 
     WaitHandle.WaitAll(events); 
    } 




} 

public class MyWorkItem 
{ 
    public AutoResetEvent Event { get; set; } 
    public MyDataClass Data { get; set; } 
} 

// You can also use DataRow instead 
public class MyDataClass 
{ 
    //data 
    // 
} 
} 

Si vous utilisez .net 4.0 - examiner les tâches et extensions parallèles (PLINQ)