Comment mettre en file d'attente une action de port d'achèvement (fonction liée E/S) à CLR ThreadPool

Question

J'ai une bibliothèque externe qui exécute des E/S de longue durée. Je souhaite créer une application multithread qui utilisera ThreadPool pour limiter le nombre simultané de fils et je veux ajouter des fils distribuaient ces appels externes en tant que fils de port d'achèvement (fils d'E/S) plutôt que les threads de travail (de sorte que la limite de calcul liée threads) est intact.

J'ai un exemple de code, qui omet la bibliothèque externe, mais montre ce que je l'ai déjà essayé.

Est-ce que quelqu'un sait comment faire cela? Ou est-ce même possible. Merci

using System; 
using System.Threading; 
using System.Net; 
using System.Net.Sockets; 
using System.Text; 

namespace ThreadPoolTest 
{ 
    class MainApp 
    { 
     static void Main() 
     { 
      ThreadPool.SetMaxThreads(10, 10); 
      ThreadPool.QueueUserWorkItem(DoWork); //doesn't work - a compute-bound thread 

      ThreadPool.SetMaxThreads(10, 10); 

      //doesn't work - still a compute-bound thread 
      ((Action<object>)DoWork).BeginInvoke(null, Callback, null); 

      Console.Read(); 
     } 

     static void DoWork(object o) 
     { 
      ShowAvailableThreads(); 
      //call to external library - that does a long I/O operation 
      Thread.Sleep(10); 
     } 

     static void Callback(IAsyncResult ar) 
     { 
      ShowAvailableThreads(); 
     } 

     static void ShowAvailableThreads() 
     { 
      int workerThreads, completionPortThreads; 

      ThreadPool.GetAvailableThreads(out workerThreads, 
       out completionPortThreads); 
      Console.WriteLine("WorkerThreads: {0}," + 
       " CompletionPortThreads: {1}", 
       workerThreads, completionPortThreads); 
     } 
    } 
} 

Answer 1

Vous pouvez la file d'attente de travail pour les fils d'E/S comme décrit here.

Les files d'attente QueueUserWorkItem gérées ne fonctionnent que sur les «threads de travail». à des files d'attente UnsafeQueueNativeOverlapped les fils I/O, comme le font les achèvements pour E/S asynchrones effectuées sur des objets noyau qui ont été liés à la ThreadPool via BindHandle.