Návod: Vytvoření jednoduché vícevláknové komponenty pomocí Visual C#

BackgroundWorker Nahrazuje součásti a funkce přidá System.Threading obor názvů. však System.Threading oboru názvů je zachována z důvodu zpětné kompatibility a budoucí použití rozhodnete.Další informace naleznete v tématu BackgroundWorker – přehled komponenty.

Můžete psát aplikace, které jsou schopny provádět více úloh současně.Tato možnost nazývá multithreading, nebo volného zřetězení, je efektivní způsob návrhu komponent, které jsou náročné na procesor a vyžadovat vstup uživatele.Příklad součásti, která může být použití multithreading by součást, která vypočítá mzdové informace.Komponenta může zpracovávat data do databáze zadána uživatelem v jednom podprocesu během mezd náročné výpočty byly provedeny na jiném.Spuštěním těchto procesů oddělené podprocesy uživatelé nemusí čekat na dokončení výpočtů před zadáním dat. Další počítače.V tomto návodu vytvoříte jednoduchý podprocesy součást, která provádí složité výpočty několik současně.

Vytváření projektu

Aplikace bude sestávat z jediného formuláře a komponenty.Uživatel zadá hodnoty a signál součásti začít výpočty.Formulář pak zobrazí hodnoty z komponenty a jejich zobrazení v popisku.Komponenta bude provádět náročné výpočty a signál po dokončení formuláře.Veřejné proměnné vytvořené v komponentě uložit hodnoty, z uživatelského rozhraní.Bude také implementovat metody v komponentě provádět výpočty na základě hodnot těchto proměnných.

[!POZNÁMKA]

Přestože je funkce obvykle výhodnější metody pro výpočet hodnoty, argumenty nelze předávat mezi podprocesy ani mohou být vráceny hodnoty.Mnoha způsoby jednoduché hodnoty podprocesům a přijímat jejich hodnoty.V této ukázce aktualizací veřejné proměnné budou vracet hodnoty uživatelského rozhraní a události bude informovat hlavní program po dokončení spuštění podprocesu.

Dialogová okna a příkazy v nabídkách menu, které vidíte, se mohou lišit od těch popsaných v nápovědě, v závislosti na vašich aktivních nastaveních nebo edici.Chcete-li změnit nastavení, zvolte Import and Export Settings v menu Nástroje.Další informace naleznete v tématu Přizpůsobení nastavení pro vývoj v sadě Visual Studio.

Chcete-li vytvořit formulář

1. Vytvoření nového Aplikace systému Windows projektu.

2. Název aplikace Calculations a přejmenujte Form1.cs jako frmCalculations.cs .Při vás vyzve k přejmenování Form1 kód prvek, klepněte na tlačítko Ano.

   Tento formulář bude sloužit jako primární uživatelské rozhraní aplikace.

3. Pět Label řídí čtyři Button ovládací prvky a jeden TextBox ovládacího prvku do formuláře.

4. Nastavení vlastnosti pro tyto ovládací prvky:

   Ovládací prvek	Název	Text
   label1	lblFactorial1	(prázdné)
   label2	lblFactorial2	(prázdné)
   label3	lblAddTwo	(prázdné)
   label4	lblRunLoops	(prázdné)
   label5	lblTotalCalculations	(prázdné)
   button1	btnFactorial1	Faktoriálu
   button2	btnFactorial2	Faktoriálu - 1
   button3	btnAddTwo	Přidejte dvě
   button4	btnRunLoops	Spuštění smyčky
   textBox1	txtValue	(prázdné)

Vytvoření komponenty programu Kalkulačka

1. Z projektu nabídce Přidat součást.

2. Název součásti Calculator .

Přidat součást Kalkulačka veřejné proměnné

1. Otevřít Editor kódu pro Calculator .

2. Přidejte příkazy k vytvoření veřejné proměnné, které budete používat k předání hodnoty z frmCalculations pro každý podproces.

   Proměnná varTotalCalculations bude udržovat průběžný součet celkového počtu výpočty prováděné komponenty a jiné proměnné bude přijímat hodnoty z formuláře.

   public int varAddTwo; 
   public int varFact1;
   public int varFact2;
   public int varLoopValue;
   public double varTotalCalculations = 0;
   

Přidání metod a událostí součásti programu Kalkulačka

1. Deklarujte delegátů pro události, které komponenta bude používat ke komunikaci hodnot do formuláře.

   [!POZNÁMKA]

   Ačkoli bude deklarování čtyři události, stačí vytvořit tři delegáty, protože dvě události bude mít stejný podpis.

   Bezprostředně pod deklarace proměnných zadali v předchozím kroku zadejte následující kód:

   // This delegate will be invoked with two of your events.
   public delegate void FactorialCompleteHandler(double Factorial, double TotalCalculations);
   public delegate void AddTwoCompleteHandler(int Result, double TotalCalculations);
   public delegate void LoopCompleteHandler(double TotalCalculations, int Counter);
   

2. Události, které komponenta bude používat ke komunikaci s aplikací Deklarujte.To lze proveďte přidáním následujícího kódu bezprostředně pod kód zadali v předchozím kroku.

   public event FactorialCompleteHandler FactorialComplete;
   public event FactorialCompleteHandler FactorialMinusOneComplete;
   public event AddTwoCompleteHandler AddTwoComplete;
   public event LoopCompleteHandler LoopComplete;
   

3. Bezprostředně pod kód, který jste zadali v předchozím kroku, zadejte následující kód:

   // This method will calculate the value of a number minus 1 factorial
   // (varFact2-1!).
   public void FactorialMinusOne()
   {
      double varTotalAsOfNow = 0;
      double varResult = 1;
      // Performs a factorial calculation on varFact2 - 1.
      for (int varX = 1; varX <= varFact2 - 1; varX++)
      {
         varResult *= varX;
         // Increments varTotalCalculations and keeps track of the current 
         // total as of this instant.
         varTotalCalculations += 1;
         varTotalAsOfNow = varTotalCalculations;
      }
      // Signals that the method has completed, and communicates the 
      // result and a value of total calculations performed up to this 
      // point.
      FactorialMinusOneComplete(varResult, varTotalAsOfNow);
   }
   
   // This method will calculate the value of a number factorial.
   // (varFact1!)
   public void Factorial()
   {
      double varResult = 1;
      double varTotalAsOfNow = 0;
      for (int varX = 1; varX <= varFact1; varX++)
      {
         varResult *= varX;
         varTotalCalculations += 1;
         varTotalAsOfNow = varTotalCalculations;
      }
      FactorialComplete(varResult, varTotalAsOfNow);
   }
   
   // This method will add two to a number (varAddTwo+2).
   public void AddTwo()
   {
      double varTotalAsOfNow = 0;  
      int varResult = varAddTwo + 2;
      varTotalCalculations += 1;
      varTotalAsOfNow = varTotalCalculations;
      AddTwoComplete(varResult, varTotalAsOfNow);
   }
   
   // This method will run a loop with a nested loop varLoopValue times.
   public void RunALoop()
   {
      int varX;
      double varTotalAsOfNow = 0;
      for (varX = 1; varX <= varLoopValue; varX++)
      {
       // This nested loop is added solely for the purpose of slowing down
       // the program and creating a processor-intensive application.
         for (int varY = 1; varY <= 500; varY++)
         {
            varTotalCalculations += 1;
            varTotalAsOfNow = varTotalCalculations;
         }
      }
      LoopComplete(varTotalAsOfNow, varLoopValue);
   }
   

Přenos vstup uživatele součásti

Dalším krokem je přidání kódu frmCalculations pro vstup od uživatele a pro přenos a příjem hodnoty do a z Calculator komponent.

K implementaci klientské funkce frmCalculations

1. Otevřít frmCalculations v Editor kódu.

2. Vyhledejte public partial class frmCalculations prohlášení.Bezprostředně pod { typu:

   Calculator Calculator1;
   

3. Vyhledejte konstruktor.Bezprostředně před }, přidejte následující řádek:

   // Creates a new instance of Calculator.
   Calculator1 = new Calculator();
   

4. V Návrháři klepněte na každé tlačítko Generovat kód osnovy pro každý ovládací prvek Click obslužné rutiny událostí a přidat kód obslužných rutin.

   Po dokončení vaše Click obslužné rutiny události by měl vypadat následující:

   // Passes the value typed in the txtValue to Calculator.varFact1.
   private void btnFactorial1_Click(object sender, System.EventArgs e)
   {
      Calculator1.varFact1 = int.Parse(txtValue.Text);
      // Disables the btnFactorial1 until this calculation is complete.
      btnFactorial1.Enabled = false;
      Calculator1.Factorial();
   }
   
   private void btnFactorial2_Click(object sender, System.EventArgs e)
   {
      Calculator1.varFact2 = int.Parse(txtValue.Text);
      btnFactorial2.Enabled = false;
      Calculator1.FactorialMinusOne();
   }
   private void btnAddTwo_Click(object sender, System.EventArgs e)
   {
      Calculator1.varAddTwo = int.Parse(txtValue.Text);
      btnAddTwo.Enabled = false;
      Calculator1.AddTwo();
   }
   private void btnRunLoops_Click(object sender, System.EventArgs e)
   {
      Calculator1.varLoopValue = int.Parse(txtValue.Text);
      btnRunLoops.Enabled = false;
      // Lets the user know that a loop is running
      lblRunLoops.Text = "Looping";
      Calculator1.RunALoop();
   }
   

5. Po kódu přidány v předchozím kroku, zadejte následující zpracování události formuláře obdrží od Calculator1 :

   private void FactorialHandler(double Value, double Calculations)
   // Displays the returned value in the appropriate label.
   {
      lblFactorial1.Text = Value.ToString();
      // Re-enables the button so it can be used again.
      btnFactorial1.Enabled = true;
      // Updates the label that displays the total calculations performed
      lblTotalCalculations.Text = "TotalCalculations are " + 
         Calculations.ToString();
   }
   
   private void FactorialMinusHandler(double Value, double Calculations)
   {
      lblFactorial2.Text = Value.ToString();
      btnFactorial2.Enabled = true;
      lblTotalCalculations.Text = "TotalCalculations are " + 
         Calculations.ToString();
   }
   
   private void AddTwoHandler(int Value, double Calculations)
   {
      lblAddTwo.Text = Value.ToString();
      btnAddTwo.Enabled = true;
      lblTotalCalculations.Text = "TotalCalculations are " +
         Calculations.ToString();
   }
   
   private void LoopDoneHandler(double Calculations, int Count)
   {
      btnRunLoops.Enabled = true;
      lblRunLoops.Text = Count.ToString();
      lblTotalCalculations.Text = "TotalCalculations are " +
         Calculations.ToString();
   }
   

6. V konstruktoru frmCalculations, těsně před přidáním následujícího kódu } pro zpracování událostí vlastní formuláře obdrží od Calculator1.

   Calculator1.FactorialComplete += new
      Calculator.FactorialCompleteHandler(this.FactorialHandler);
   Calculator1.FactorialMinusOneComplete += new
      Calculator.FactorialCompleteHandler(this.FactorialMinusHandler);
   Calculator1.AddTwoComplete += new
      Calculator.AddTwoCompleteHandler(this.AddTwoHandler);
   Calculator1.LoopComplete += new
      Calculator.LoopCompleteHandler(this.LoopDoneHandler);
   

Testování aplikace

Nyní jste vytvořili projekt, který zahrnuje formulář a součást provést několik složitých výpočtů.Přestože multithreading funkce nebyla dosud implementována, bude test ověřit jeho funkčnost před pokračováním projektu.

Testování projektu

1. Z ladění nabídce zvolte Spustit ladění.

   Začne aplikace a frmCalculations se zobrazí.

2. Do textového pole zadejte 4, klepněte na tlačítko s názvem Přidat dva.

   Číslicí "6" má být zobrazen v popisku pod ní a "Celkové výpočty jsou 1" zobrazí v lblTotalCalculations .

3. Nyní klepněte na tlačítko faktoriálu - 1.

   Číslo "6" by měl být zobrazen pod tlačítko, a lblTotalCalculations nyní přečte "Celková výpočty jsou 4".

4. Změňte hodnotu v textovém poli na 20, klepněte na tlačítko s názvem faktoriálu.

   Zobrazí se číslo "2.43290200817664E + 18" pod ní, a lblTotalCalculations nyní přečte "Jsou výpočty celkem 24."

5. Změňte hodnotu v textovém poli na 50000a klepněte na tlačítko s názvem Spuštění smyčky a.

   Všimněte si, že malé ale znatelný interval před klepnutím na toto tlačítko znovu povolena."50000" Určen štítku podle tohoto tlačítka a zobrazí celkový výpočty jsou "25000024"

6. Změňte hodnotu v textovém poli na 5 000 000 a klepněte na tlačítko Spuštění smyčky a, ihned klepněte na tlačítko Přidat dva.Klepněte znovu.

   Tlačítko nereaguje ani libovolného ovládacího prvku formuláře odpoví dokud smyčky.

   Pokud se program spustí pouze jeden podproces provádění, náročné výpočty, například výše uvedený příklad mají tendenci k programu dokud výpočty.V další části se přidat multithreading schopnost aplikace tak, aby více podprocesů může běžet současně.

Přidání Multithreading schopnost

V předchozím příkladu prokázáno omezení aplikace, které pracují pouze jediný podproces provádění.V další části se budou používat Thread třídy komponenty přidat více podprocesů spuštění.

Chcete-li přidat podprogram podprocesů

1. Otevřít Calculator.cs v Editor kódu.

2. V horní části kód vyhledejte deklaraci třídy a bezprostředně pod {, zadejte následující příkaz:

   // Declares the variables you will use to hold your thread objects.
   public System.Threading.Thread FactorialThread; 
   public System.Threading.Thread FactorialMinusOneThread;  
   public System.Threading.Thread AddTwoThread; 
   public System.Threading.Thread LoopThread;
   

3. Bezprostředně před koncem deklaraci třídy v dolní části kódu přidejte následující metodu:

   public void ChooseThreads(int threadNumber)
   {
   // Determines which thread to start based on the value it receives.
   switch(threadNumber)
      {
         case 1:
            // Sets the thread using the AddressOf the subroutine where
            // the thread will start.
            FactorialThread = new System.Threading.Thread(new
               System.Threading.ThreadStart(this.Factorial));
            // Starts the thread.
            FactorialThread.Start();
            break;
         case 2:
            FactorialMinusOneThread = new
               System.Threading.Thread(new
                  System.Threading.ThreadStart(this.FactorialMinusOne));
            FactorialMinusOneThread.Start();
            break;
         case 3:
            AddTwoThread = new System.Threading.Thread(new
                System.Threading.ThreadStart(this.AddTwo));
            AddTwoThread.Start();
            break;
         case 4:
            LoopThread = new System.Threading.Thread(new
               System.Threading.ThreadStart(this.RunALoop));
            LoopThread.Start();
            break;
      }
   }
   

   Když Thread je konkretizováno, vyžaduje argument ve formě ThreadStart.ThreadStart Je delegát odkazující na adresu metoda kde má začít podprocesu.A ThreadStart nelze převzít parametry nebo hodnoty průchodu a proto lze pouze označení void metoda. ChooseThreads Metoda právě implementována bude přijímat volání je program hodnotu a tuto hodnotu použít k určení vhodných podproces spuštění.

Přidat příslušný kód frmCalculations

1. Otevřít frmCalculations.cs v souboru Editor kódu, vyhledejte private void btnFactorial1_Click .

   1. Řádek, který volá komentář Calculator1.Factorial1 přímo podle metody:

      // Calculator1.Factorial()
      

   2. Přidejte následující řádek volání Calculator1.ChooseThreads metoda:

      // Passes the value 1 to Calculator1, thus directing it to start the 
      // correct thread.
      Calculator1.ChooseThreads(1);
      

2. Provádět podobné úpravy druhé button_click metod.

   [!POZNÁMKA]

   Být určité zahrnout hodnotu odpovídající Threads argument.

   Po dokončení, by měl vypadat jako následující kód:

   private void btnFactorial1_Click(object sender, System.EventArgs e)
   // Passes the value typed in the txtValue to Calculator.varFact1
   {
      Calculator1.varFact1 = int.Parse(txtValue.Text);
      // Disables the btnFactorial1 until this calculation is complete
      btnFactorial1.Enabled = false;
      // Calculator1.Factorial();
      Calculator1.ChooseThreads(1);
   }
   
   private void btnFactorial2_Click(object sender, System.EventArgs e)
   {
      Calculator1.varFact2 = int.Parse(txtValue.Text); 
      btnFactorial2.Enabled = false;         
      // Calculator1.FactorialMinusOne();
      Calculator1.ChooseThreads(2);
   }
   private void btnAddTwo_Click(object sender, System.EventArgs e)
   {
      Calculator1.varAddTwo = int.Parse(txtValue.Text);
      btnAddTwo.Enabled = false;
      // Calculator1.AddTwo();
      Calculator1.ChooseThreads(3);
   }
   
   private void btnRunLoops_Click(object sender, System.EventArgs e)
   {
      Calculator1.varLoopValue = int.Parse(txtValue.Text);
      btnRunLoops.Enabled = false;
      // Lets the user know that a loop is running
      lblRunLoops.Text = "Looping";
      // Calculator1.RunALoop();
      Calculator1.ChooseThreads(4);
   }
   

Zařazování volání ovládacích prvků

Nyní vám usnadní aktualizaci zobrazení ve formuláři.Protože ovládací prvky jsou majetkem vždy hlavní podproces provádění, vyžaduje každé volání ovládacího prvku z podřízeného podprocesu zařazování volání.Zařazování je úkon, přesunutí volání přes hranice podprocesu a je velmi náročné prostředcích.Minimalizace množství zařazování, který potřebuje dochází a ujistěte se, že volání jsou zpracovány v podprocesu, můžete použít Control.BeginInvoke metoda k vyvolání metod na hlavní podproces provádění, a tím minimalizace množství zařazování křížové podproces hranice, ke kterému musí dojít.Tento druh volání je nutné při volání metody umožňující pracovat s prvky.Další informace naleznete v tématu Postupy: Manipulace s ovládacími prvky z vláken.

Chcete-li vytvořit postupy řízení volání

1. Otevřít editor kódu pro frmCalculations .V sekci deklarací přidejte následující kód:

   public delegate void FHandler(double Value, double Calculations);
   public delegate void A2Handler(int Value, double Calculations);
   public delegate void LDHandler(double Calculations, int Count);
   

   Invokea BeginInvoke vyžadují delegát vhodné metody jako argument.Tyto řádky delegáta deklarovat, podpisy, které budou použity v BeginInvoke vyvolat vhodných metod.

2. Přidejte následující metody prázdný kód.

   public void FactHandler(double Value, double Calculations)
   {
   }
   public void Fact1Handler(double Value, double Calculations)
   {
   }
   public void Add2Handler(int Value, double Calculations)
   {
   }
   public void LDoneHandler(double Calculations, int Count)
   {
   }
   

3. Z Upravit nabídce použít Vyjmout a Vložit k vyjmutí všech kód z metody FactorialHandler a vložit jej do FactHandler .

4. Repeat the previous step for FactorialMinusHandler and Fact1Handler, AddTwoHandler and Add2Handler, and LoopDoneHandler and LDoneHandler.

   Po dokončení by měla být žádný kód zbývající v FactorialHandler , Factorial1Handler , AddTwoHandler , a LoopDoneHandler a všechny tyto obsahoval by byly přesunuty do nové vhodné metody kódu.

5. Volání BeginInvoke metoda vyvolat metody asynchronně.Můžete volat BeginInvoke buď z formuláře (this) nebo ovládacích prvků ve formuláři.

   Po dokončení by měl vypadat jako následující kód:

   protected void FactorialHandler(double Value, double Calculations)
   {
      // BeginInvoke causes asynchronous execution to begin at the address
      // specified by the delegate. Simply put, it transfers execution of 
      // this method back to the main thread. Any parameters required by 
      // the method contained at the delegate are wrapped in an object and 
      // passed. 
      this.BeginInvoke(new FHandler(FactHandler), new Object[]
         {Value, Calculations});
   }
   protected void FactorialMinusHandler(double Value, double Calculations)
   {
      this.BeginInvoke(new FHandler(Fact1Handler), new Object []
         {Value, Calculations});
   }
   
   protected void AddTwoHandler(int Value, double Calculations)
   {
      this.BeginInvoke(new A2Handler(Add2Handler), new Object[]
         {Value, Calculations});
   }
   
   protected void LoopDoneHandler(double Calculations, int Count)
   {
      this.BeginInvoke(new LDHandler(LDoneHandler), new Object[]
         {Calculations, Count});
   }
   

   To může zdát obslužná rutina události je jednoduše volání k další metodě.Obslužná rutina události skutečně způsobuje metoda vyvolat v hlavní podproces operace.Tento přístup se uloží na volání přes hranice podprocesu a umožňuje spouštění účinně a bez obav způsobit zamrznutí podprocesy aplikací.Podrobné informace o práci s ovládacími prvky v prostředí s více podprocesy, viz Postupy: Manipulace s ovládacími prvky z vláken.

6. Uložte svou práci.

7. Test řešení výběrem Spustit ladění z ladění nabídce.

   1. Typ 10000000 v textovém poli a klepněte na Spuštění smyčky a.

      "Opakování" je zobrazený v popisku pod toto tlačítko.Tento cyklus brát značné množství času spuštění.Pokud dokončí příliš brzy, odpovídajícím způsobem upravte velikost čísla.

   2. Rychle za sebou klepněte na všechny tři tlačítka, které jsou stále povoleny.Zjistíte, že všechna tlačítka odpovědět vstup.Popisek pod Přidat dva by měl být první zobrazení výsledku.Výsledky budou zobrazeny později v popiscích pod faktoriálu tlačítka.Tyto výsledky vyhodnotit do nekonečna, jako je příliš velký pro proměnnou s dvojitou přesností obsahovat číslo vrácené 10,000,000 faktoriálu.Nakonec další zpožděním výsledky pod Spuštění smyčky a tlačítko.

      Jako je právě pozorovaných čtyři samostatné sady výpočty byly prováděny současně čtyři oddělené podprocesy.Uživatelské rozhraní zůstala reagovat na vstup a byly vráceny po každý podproces dokončena.

Koordinovat své podprocesů

Zkušení uživatelé s více podprocesy aplikací může vnímat decentní chyba s kódem jako zadali.Odvolání řádky kódu z každé metody provádění výpočtů v Calculator :

varTotalCalculations += 1;
varTotalAsOfNow = varTotalCalculations;

Tyto dva řádky kódu zvýšit veřejné proměnné varTotalCalculations a nastavte místní proměnné varTotalAsOfNow na tuto hodnotu.Tato hodnota je poté zaslána frmCalculations a zobrazeny v ovládacím prvku popisek.Ale je správné hodnoty vracené?Pokud pouze jeden podproces provádění je spuštěn, je jasně odpověď Ano.Ale pokud více podprocesů, odpověď se stává více neurčité.Každý podproces má možnost zvýšit proměnnou varTotalCalculations .Je možné, že po jeden podproces zvýší tuto proměnnou, ale před zkopíruje hodnotu na varTotalAsOfNow , jiný podproces mohly zvětšením je hodnota této proměnné.To vede k možnost každý podproces je ve skutečnosti vykazování nepřesné výsledky.Visual C#poskytuje lock – příkaz (Referenční dokumentace jazyka C#) povolení synchronizace podprocesů, aby každý podproces vrací vždy přesné výsledky.Syntaxe funkce lock je následující:

lock(AnObject)
{
   // Insert code that affects the object.
   // Insert more code that affects the object.
   // Insert more code that affects the object.
// Release the lock.
}

Když lock bloku je zapsáno, spuštění zadaného výrazu blokována, dokud Zadaný podproces má výhradní zámek u daného objektu.Ve výše uvedeném příkladu je blokováno spuštění na AnObject .lockmusí být použita s objektem, který vrací odkaz, nikoli hodnotu.Provádění pokračovat potom blok bez rušení z jiných podprocesů.Sadu příkazů, které jako celek, jsou označeny jako atomovou.Když } je zjistil, uvolněno výraz a podprocesy mohou pokračovat normálně.

Přidání příkazu Zamknout do aplikace

1. Otevřít Calculator.cs v Editor kódu.

2. Vyhledejte každou instanci následující kód:

   varTotalCalculations += 1;
   varTotalAsOfNow = varTotalCalculations;
   

   Měl by být čtyři instance tohoto kódu, jeden v každé metody výpočtu.

3. Tento kód upravte tak, aby se nahrazuje tímto:

   lock(this)
   {
      varTotalCalculations += 1;
      varTotalAsOfNow = varTotalCalculations;
   }
   

4. Uložte práci a vyzkoušet jako v předchozím příkladu.

   Můžete zaznamenat mírné dopad na výkon aplikace.Důvodem je provádění podprocesů zastavíte na komponenty se získá výhradní zámek.Přestože zajišťuje přesnost, tento přístup brání některé výhody výkonu více podprocesů.By měly pečlivě zvážit potřebu zamykání podprocesů a je pouze v krajním případě provede.

Viz také

Úkoly

Postupy: Koordinace více vláken provádění

Návod: Vytvoření jednoduché vícevláknové komponenty pomocí sady Visual Basic

Referenční dokumentace

BackgroundWorker

Koncepty

Přehled asynchronních vzorů založených na událostech

Další zdroje

Programování pomocí komponent

Návody pro programování komponent

Použití více vláken v komponentách