Threading




C# Workshop, TU Darmstadt 2008,
Präsentation von Qiong Wu (Microsoft Junior Student Partner)
   Prozesse / Threads?
   Arbeiten mit Threads
   Erstellen von Threads
   Threads beenden
   Datenzugriff mit Thread...
   Ablaufende Programme
   Heißen unter Windows auch Tasks
   Erlauben einem Prozessor mehrere Aufgaben
    „gleichzeit...
   Teilbereiche eines Prozesses
   Erlauben einem Prozess mehrere Aufgaben
    „gleichzeitig“ zu bearbeiten.
   Teilen ...
   Beides Konzepte zur parallelen
    Programmierung
   Prozesse sind unabhängige
    Ausführungseinheiten
   Threads a...
   Parallelisieren von Programmaufgaben
   Nutzen von Multi-Threaded Hardware
    (Multicore, Multiprozessor)
   Trennu...
   Threads können die Performance
    beeinträchtigen (Thread Overhead)
   Threads sind häufige Fehlerquellen
   Viele ...
   Multithreading in C# relativ einfach
   Unterstützt asynchrones und synchrones
    Threading
   Wichtigstes Werkzeug...
   Manuelles Erstellen von Threads
   Beenden von Threads
   Datenzugriffe koordinieren
   Asynchrone Programmierung
...
1.   Methode für Threadeinstiegspunkt erstellen
2.   ParametrizedThreadStart / ThreadStart
     Delegaten mit Verweis auf ...
   ThreadStart
     für parameterlose Threadmethoden
   ParametrizedThreadStart
     für Threadmethoden mit Parameter
...
Auszuführende
                                         Methode
static void Main(string[] args)
{
    ThreadStart TestThrea...
Auszuführende
                                                            Methode
static void Main(string[] args)
{
    Pa...
   Unterscheidung zwischen
     Foreground Threads
     Background Threads
   Thread.Join()
Thread ForegroundThread = new Thread(new ThreadStart(ThreadMethod));
ForegroundThread.Start();
                           ...
ThreadStart operation = new ThreadStart(ThreadMethod);
Thread[] theThreads = new Thread[5];
for (int x = 0; x <= 4; ++x)
{...
   Bestimmt die Vorrangregelung bei der
    Ausführung eines Threads
   Thread.Priority Eigenschaft
   ThreadPriority E...
Standardpriorität ist
                                               ThreadPriority.Normal


Thread NormalPriorityThread =...
   Thread.Abort()
     Löst ThreadAbortException aus
     Beendet Thread nach Auslösen der Exception
   Sicheres Beend...
static void Main(string[] args)
{
    Thread newThread = new Thread(new ThreadStart(ThreadMethod));
    newThread.Start();...
static void ThreadMethod()
{
    try
    {
        for (int i = 0; i < 100; i++)
        {
            Console.WriteLine(q...
   Einige Programmieren raten von
    Thread.Abort ab
   Gründe
     Thread.Abort kann Thread an jeder Stelle
      abb...
static void TestManualAbort()
{
    Thread newThread = new Thread(new ThreadStart(ManualAbortThreadMethod));
    newThread...
   Probleme mit Thread.Abort() lassen sich auch
    ohne Abortvariable umgehen
   Alternative Lösungen
     Code auf Th...
Oder einfach Pause?
   Vor Multithreading: Nur ein gleichzeitiger
    Zugriff auf Daten
   Mit Multithreading: Möglichkeit des
    gleichzei...
   Mehrere Threads können eine gemeinsame
    Variable manipulieren
   Probleme beim Rückschreiben von Werten
   Fehler...
Thread 1                                     Thread 2
X = X + 30                                   X = X + 15




     Var...
Thread 1         Thread 2
  X=0              X=0




           X=0
Thread 1         Thread 2
 X=30              X=0




           X=0
Thread 1                       Thread 2
 X=30                           X=15




    Variable schreiben
                  ...
Thread 1                          Thread 2
Beenden…                            X=15




                     Variable schr...
Thread 2
         Beenden…




X = 15
X = 15
   Interlocked Klasse
   Synchronisierungssperren
   Bietet atomare Operationen für Variablen
   Nur für triviale Operationen an einer Variable
    (Addieren, Dekrementie...
   Monitor.Enter() + Monitor.Exit()
   Lock Schlüsselwort
   ReaderWriterLock
   Mutex / Semaphore / AutoResetEvent /
...
   Setzt in Codeabschnitt eine
    Synchronisierungssperre
   Synchronisieren auf ein Objekt
     Besitzer des Monitor ...
   Synchronisierungsobjekt als Parameter
   Umschließt Codebereich implizit mit
    Monitor.Enter() und Monitor.Exit()
Sperrvariable


public static object Lockvar = new object();
public static void LockMethod(object Parameter)
{
    Monitor...
Sperrvariable


public static object Lockvar = new object();
public static void LockMethod(object Parameter)
{
    lock (L...
   Zwei Threads schließen sich gegenseitig
    durch Synchronisationssperren aus
   Thread A wartet auf Thread B, Thread...
public static object Lockvar1 = new object();
                  public static object Lockvar2 = new object();
            ...
   Sorgfältig Programmieren!
   Monitor.TryEnter() mit Zeitlimit
   Kurze Codeabschnitte sperren
   ReaderWriteLock Klasse ermöglicht
     Ausschließliche Lesesperre
     Schreibsperre
     Wechsel von Lese zu Schre...
Oder noch eine Pause?
   Erstellung eigener Threads oft unnötig
   ThreadPool verwaltet Threads die auf Abruf
    bereit stehen, Standardanzah...
   ThreadPool.QueueUserWorkItem
     Übergabe von Verweis auf Funktion
     Optional: Übergabe von Parameter
   Thread...
WaitCallback Delegate
                                                    Thread mit Parameter starten


WaitCallback work...
   Idee: Asynchrones Starten & Beenden eines
    Ablaufs
   Vorteile
     Keine manuelle Verwaltung des Threads notwend...
   Asynchrone Operation starten
   Andere Arbeiten erledigen
   Mit EndXXX auf Ende der Operation warten
Andere Arbeiten ausführen


Console.WriteLine(quot;Start Async Fetchin..quot;);
GenericMethodDelegate<int> method = IntFet...
   Starten der asnychronen Operation
   Regelmäßig überprüfen ob die Operation
    abgeschlossen ist
   Nach Abgeschlos...
Andere Arbeiten ausführen

Console.WriteLine(quot;Start Async Fetchin..quot;);
IAsyncResult ar2 = method.BeginInvoke(null,...
   Starten der asynchronen Operation mit
    Übergabe einer Rückruffunktion
Andere Arbeiten ausführen                      Callback Funktion angeben

Console.WriteLine(quot;Start Async Fetchin..quot...
   Try Catch bei Aufruf der EndXXX Methode
    anwenden
     try
     {
           Console.WriteLine(quot;Got quot; + met...
   Delegaten erstellen
   BeginInvoke des Delegaten aufrufen
   EndInvoke des Delegaten aufrufen
Delegat auf auszuführende
        Methode

   public delegate TOutput GenericMethodDelegate<TOutput>();
                  ...
   Ruft eine Methode asynchron nach
    Zeitspanne auf
   Wiederholt Aufruf der Methode nach
    Zeitspanne
   Timer.Ch...
Tick Intervall

        TimerCallbackDelegate            Startverzögerung

static void TestTimer()
{
    Timer tm = new Ti...
   Häufigster Anwendungsfall für Threading:
    Rechenlast aus GUIs auslagern
   Dem Hauptthread möglichst wenig
    Rec...
private void cmdThreaded_Click(object sender, EventArgs e)
{
    Thread FormsThread = new Thread(new ThreadStart(DoWork));...
private void button1_Click(object sender, EventArgs e)
{
    Thread FormsThread = new Thread(new ThreadStart(ManipulateLis...
   Direktes Manipulieren von Windows Forms
    Steuerelementen löst Exception aus
   Mit Invoke den UI Thread auffordern...
Delegat nach Funktion
                                                    erstellen

private delegate void ManipulateListD...
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
C# Workshop - Threading
Upcoming SlideShare
Loading in …5
×

C# Workshop - Threading

4,842 views

Published on

That's the slides for our C# Workshop at Darmstadt University of Technology, powered by Microsoft Student Partners.

Published in: Technology
1 Comment
2 Likes
Statistics
Notes
  • Unglaublich guter workshop.
    Es gibt hilfreiche Code Beispiele, die einzelnen Folien sind sehr informativ und nicht überladen. Informativ auch wenn man schon einiges über Threads weiß.
    S.
       Reply 
    Are you sure you want to  Yes  No
    Your message goes here
No Downloads
Views
Total views
4,842
On SlideShare
0
From Embeds
0
Number of Embeds
256
Actions
Shares
0
Downloads
79
Comments
1
Likes
2
Embeds 0
No embeds

No notes for slide

C# Workshop - Threading

  1. 1. Threading C# Workshop, TU Darmstadt 2008, Präsentation von Qiong Wu (Microsoft Junior Student Partner)
  2. 2.  Prozesse / Threads?  Arbeiten mit Threads  Erstellen von Threads  Threads beenden  Datenzugriff mit Threads  Deadlocks  ThreadPools  Asnychrone Programmierung  Timer  Windows Forms & Threading
  3. 3.  Ablaufende Programme  Heißen unter Windows auch Tasks  Erlauben einem Prozessor mehrere Aufgaben „gleichzeitig“ zu bearbeiten  Interprozesskommunikation  Besitzen  Virtuellen Adressspeicher  Ausführbaren Code  Mindestens einen Ausführungsthread
  4. 4.  Teilbereiche eines Prozesses  Erlauben einem Prozess mehrere Aufgaben „gleichzeitig“ zu bearbeiten.  Teilen sich virtuellen Adressspeicher und die Systemressourcen des Prozesses zu dem sie gehören  C# Programme starten automatisch Hauptthread
  5. 5.  Beides Konzepte zur parallelen Programmierung  Prozesse sind unabhängige Ausführungseinheiten  Threads als logische Arbeitsteile eines Prozesses  Parallelisierung sowohl mit mehreren Prozessen als auch mehreren Threads theoretisch möglich
  6. 6.  Parallelisieren von Programmaufgaben  Nutzen von Multi-Threaded Hardware (Multicore, Multiprozessor)  Trennung von Benutzeroberfläche und Berechnung  Verteilte Systeme
  7. 7.  Threads können die Performance beeinträchtigen (Thread Overhead)  Threads sind häufige Fehlerquellen  Viele Threads bedeuten auch viel Ärger  Ergo: Threading nur dann einsetzen wenn es sinnvoll ist!
  8. 8.  Multithreading in C# relativ einfach  Unterstützt asynchrones und synchrones Threading  Wichtigstes Werkzeug: System.Threading Namespace
  9. 9.  Manuelles Erstellen von Threads  Beenden von Threads  Datenzugriffe koordinieren  Asynchrone Programmierung  ThreadPool verwenden
  10. 10. 1. Methode für Threadeinstiegspunkt erstellen 2. ParametrizedThreadStart / ThreadStart Delegaten mit Verweis auf die Einstiegsmethode erstellen 3. Thread Objekt mit Delegaten erstellen 4. Optional: Threadeigenschaften festlegen 5. Thread starten
  11. 11.  ThreadStart  für parameterlose Threadmethoden  ParametrizedThreadStart  für Threadmethoden mit Parameter  Parameter muss vom Typ object sein
  12. 12. Auszuführende Methode static void Main(string[] args) { ThreadStart TestThreadStart = new ThreadStart(ThreadMethod); Thread TestThread = new Thread(TestThreadStart); TestThread.Name = quot;Test Threadquot;; TestThread.Priority = ThreadPriority.Normal; TestThread.IsBackground = false; TestThread.Start(); Threadoptionen Console.ReadLine(); } Kein Rückgabewert static void ThreadMethod() { Console.WriteLine(quot;Thread Runquot;); }
  13. 13. Auszuführende Methode static void Main(string[] args) { ParameterizedThreadStart TestThreadStart = new ParameterizedThreadStart(ThreadMethod); Thread TestThread = new Thread(TestThreadStart); TestThread.Name = quot;Test Threadquot;; TestThread.Priority = ThreadPriority.Normal; Threadoptionen TestThread.IsBackground = false; TestThread.Start(quot;Testquot;); Start mit Parameter Console.ReadLine(); } Kein Rückgabewert object Parameter static void ThreadMethod(object Parameter) { Console.WriteLine(quot;Thread Run with Parameter: quot; + Parameter.ToString()); }
  14. 14.  Unterscheidung zwischen  Foreground Threads  Background Threads  Thread.Join()
  15. 15. Thread ForegroundThread = new Thread(new ThreadStart(ThreadMethod)); ForegroundThread.Start(); Foreground Thread Verhindert Beenden der Applikation Thread BackgroundThread = new Thread(new ThreadStart(ThreadMethod)); BackgroundThread.IsBackground = true; BackgroundThread.Start(); Background Thread kann nach Beendigung aller Foreground Threads terminiert werden
  16. 16. ThreadStart operation = new ThreadStart(ThreadMethod); Thread[] theThreads = new Thread[5]; for (int x = 0; x <= 4; ++x) { theThreads[x] = new Thread(operation); theThreads[x].Start(); } Thread starten foreach (Thread oneThread in theThreads) { Console.WriteLine(quot;Waiting for Thread to terminatequot;); oneThread.Join(); Console.WriteLine(quot;Thread terminatedquot;); } Auf Threadende warten
  17. 17.  Bestimmt die Vorrangregelung bei der Ausführung eines Threads  Thread.Priority Eigenschaft  ThreadPriority Enum  Lowest  BelowNormal  Normal  AboveNormal  Highest
  18. 18. Standardpriorität ist ThreadPriority.Normal Thread NormalPriorityThread = new Thread(new ThreadStart(ThreadMethod)); Thread HighPriorityThread = new Thread(new ThreadStart(ThreadMethod)); HighPriorityThread.Priority = ThreadPriority.Highest; NormalPriorityThread.Start(); HighPriorityThread.Start(); Setzen der Threadpriorität auf ThreadPriority.Highest
  19. 19.  Thread.Abort()  Löst ThreadAbortException aus  Beendet Thread nach Auslösen der Exception  Sicheres Beenden von Threads  ThreadAbortException behandeln  Alternative: Abortvariable
  20. 20. static void Main(string[] args) { Thread newThread = new Thread(new ThreadStart(ThreadMethod)); newThread.Start(); Thread.Sleep(1000); newThread.Abort(); Console.ReadLine(); } Thread beenden
  21. 21. static void ThreadMethod() { try { for (int i = 0; i < 100; i++) { Console.WriteLine(quot;Thread - working.quot;); Thread.Sleep(100); } } ThreadAbortException catch (ThreadAbortException e) behandeln { Console.WriteLine(quot;Thread - caught ThreadAbortException - resetting.quot;); Console.WriteLine(quot;Exception message: {0}quot;, e.Message); } finally { Console.WriteLine(quot;Just one more message before I dropquot;); } }
  22. 22.  Einige Programmieren raten von Thread.Abort ab  Gründe  Thread.Abort kann Thread an jeder Stelle abbrechen  Finally Statements können übergangen werden  Ressourcen können ungeschlossen bleiben  Ansatz: Abortvariable einführen und im Thread pollen
  23. 23. static void TestManualAbort() { Thread newThread = new Thread(new ThreadStart(ManualAbortThreadMethod)); newThread.Start(); Thread.Sleep(1000); Abort = true; } static volatile bool Abort = false; static void ManualAbortThreadMethod() { while (true) { if (Abort == false) { Console.WriteLine(System.DateTime.Now.ToString()); } else { break; } } }
  24. 24.  Probleme mit Thread.Abort() lassen sich auch ohne Abortvariable umgehen  Alternative Lösungen  Code auf ThreadAbortException anpassen  Constrained Execution Regions einsetzen (Fortgeschritten)
  25. 25. Oder einfach Pause?
  26. 26.  Vor Multithreading: Nur ein gleichzeitiger Zugriff auf Daten  Mit Multithreading: Möglichkeit des gleichzeitigen Zugriffs auf Daten von mehreren Threads  Was passiert wenn mehrere Threads gleichzeitig einen Datenbestand manipulieren?
  27. 27.  Mehrere Threads können eine gemeinsame Variable manipulieren  Probleme beim Rückschreiben von Werten  Fehlerhafte Werte als Ergebnis
  28. 28. Thread 1 Thread 2 X = X + 30 X = X + 15 Variable einlesen Variable einlesen X=0
  29. 29. Thread 1 Thread 2 X=0 X=0 X=0
  30. 30. Thread 1 Thread 2 X=30 X=0 X=0
  31. 31. Thread 1 Thread 2 X=30 X=15 Variable schreiben X=0
  32. 32. Thread 1 Thread 2 Beenden… X=15 Variable schreiben X = 30
  33. 33. Thread 2 Beenden… X = 15
  34. 34. X = 15
  35. 35.  Interlocked Klasse  Synchronisierungssperren
  36. 36.  Bietet atomare Operationen für Variablen  Nur für triviale Operationen an einer Variable (Addieren, Dekrementieren, Vertauschen, Inkrementieren)  Effektiv, aber beschränktes Einsatzgebiet
  37. 37.  Monitor.Enter() + Monitor.Exit()  Lock Schlüsselwort  ReaderWriterLock  Mutex / Semaphore / AutoResetEvent / ManualResetEvent
  38. 38.  Setzt in Codeabschnitt eine Synchronisierungssperre  Synchronisieren auf ein Objekt  Besitzer des Monitor des Objekts erhält exklusiven Zugriff auf Codeabschnitt  Andere blockieren bis Freigabe des Monitors
  39. 39.  Synchronisierungsobjekt als Parameter  Umschließt Codebereich implizit mit Monitor.Enter() und Monitor.Exit()
  40. 40. Sperrvariable public static object Lockvar = new object(); public static void LockMethod(object Parameter) { Monitor.Enter(Lockvar); try { Anfang count++; Synchronisierungssperre Console.WriteLine(quot;Thread quot; + count + quot; Writingquot;); finally { Monitor.Exit(Lockvar); } } Ende Synchronisierungssperre
  41. 41. Sperrvariable public static object Lockvar = new object(); public static void LockMethod(object Parameter) { lock (Lockvar) Sperrvariable { count++; Console.WriteLine(quot;Thread quot; + count + quot; Writingquot;); } }
  42. 42.  Zwei Threads schließen sich gegenseitig durch Synchronisationssperren aus  Thread A wartet auf Thread B, Thread B wartet auf Thread A  Endloses Warten
  43. 43. public static object Lockvar1 = new object(); public static object Lockvar2 = new object(); public static void DeadLockMethodOne() { lock (Lockvar1) { Sperrvariable lock (Lockvar2) Sperrt Lockvar1 { Console.WriteLine(quot;Firstquot;); } } } public static void DeadLockMethodTwo() { lock (Lockvar2) { lock (Lockvar1) Sperrt Lockvar2 { Console.WriteLine(quot;Secondquot;); } } }
  44. 44.  Sorgfältig Programmieren!  Monitor.TryEnter() mit Zeitlimit  Kurze Codeabschnitte sperren
  45. 45.  ReaderWriteLock Klasse ermöglicht  Ausschließliche Lesesperre  Schreibsperre  Wechsel von Lese zu Schreibsperre und vice versa
  46. 46. Oder noch eine Pause?
  47. 47.  Erstellung eigener Threads oft unnötig  ThreadPool verwaltet Threads die auf Abruf bereit stehen, Standardanzahl 25  Overhead bei Threaderstellung und Threadvernichtung eliminiert  ThreadPool Threads sind Hintergrundthreads  ThreadPool Arbeitsaufgaben können nicht durch Fremdeinwirkung abgebrochen werden
  48. 48.  ThreadPool.QueueUserWorkItem  Übergabe von Verweis auf Funktion  Optional: Übergabe von Parameter  ThreadPool.GetMaxThreads  Anzahl der maximal verfügbaren Threads abrufen  ThreadPool.SetMaxThreads  Anzahl der maximal verfügbaren Threads festlegen
  49. 49. WaitCallback Delegate Thread mit Parameter starten WaitCallback workItem = new WaitCallback(ThreadMethod); if (!ThreadPool.QueueUserWorkItem(workItem, quot;ThreadPooledquot;)) { Console.WriteLine(quot;Element konnte nicht in Warteschlange gestellt werdenquot;); }
  50. 50.  Idee: Asynchrones Starten & Beenden eines Ablaufs  Vorteile  Keine manuelle Verwaltung des Threads notwendig  Automatische Threadskalierung  Performancegewinn durch automatische Nutzung von ThreadPool  3 Verwendungsmodelle  Warten-bis-fertig Modell  Pollingmodell  Rückrufmodell
  51. 51.  Asynchrone Operation starten  Andere Arbeiten erledigen  Mit EndXXX auf Ende der Operation warten
  52. 52. Andere Arbeiten ausführen Console.WriteLine(quot;Start Async Fetchin..quot;); GenericMethodDelegate<int> method = IntFetcher.Fetch; IAsyncResult ar = method.BeginInvoke(null, method); Methode asynchron Thread.Sleep(1000); ausführen Console.WriteLine(quot;Got quot; + method.EndInvoke(ar)); Console.WriteLine(quot;End Async Fetchin..quot;); Auf Ende der Methode warten
  53. 53.  Starten der asnychronen Operation  Regelmäßig überprüfen ob die Operation abgeschlossen ist  Nach Abgeschlossener Operation EndXXX aufrufen
  54. 54. Andere Arbeiten ausführen Console.WriteLine(quot;Start Async Fetchin..quot;); IAsyncResult ar2 = method.BeginInvoke(null, method); Methode asynchron while (!ar2.IsCompleted) ausführen { Thread.Sleep(1000); } Regelmäßig pollen Console.WriteLine(quot;Got quot; + method.EndInvoke(ar2)); Console.WriteLine(quot;End Async Fetchin..quot;); Ergebnis abrufen (keine Wartezeit)
  55. 55.  Starten der asynchronen Operation mit Übergabe einer Rückruffunktion
  56. 56. Andere Arbeiten ausführen Callback Funktion angeben Console.WriteLine(quot;Start Async Fetchin..quot;); IAsyncResult ar3 = method.BeginInvoke(new AsyncCallback(CompleteFetch), method); Thread.Sleep(1000); static void CompleteFetch(IAsyncResult result) { GenericMethodDelegate<int> method = (GenericMethodDelegate<int>)result.AsyncState; int i = method.EndInvoke(result); Console.WriteLine(quot;Got quot; + i); Console.WriteLine(quot;End Async Fetchin...quot;); } Ergebnis abrufen (keine Wartezeit)
  57. 57.  Try Catch bei Aufruf der EndXXX Methode anwenden try { Console.WriteLine(quot;Got quot; + method.EndInvoke(ar2)); } catch { Console.WriteLine(quot;Error occuredquot;); } finally { Console.WriteLine(quot;End Async Fetchin..quot;); }
  58. 58.  Delegaten erstellen  BeginInvoke des Delegaten aufrufen  EndInvoke des Delegaten aufrufen
  59. 59. Delegat auf auszuführende Methode public delegate TOutput GenericMethodDelegate<TOutput>(); Methode dem Delegat static void TestAsync() zuweisen { Console.WriteLine(quot;Start Async Fetchin..quot;); GenericMethodDelegate<int> method = IntFetcher.Fetch; IAsyncResult ar = method.BeginInvoke(null, method); Thread.Sleep(1000); Console.WriteLine(quot;Got quot; + method.EndInvoke(ar)); Console.WriteLine(quot;End Async Fetchin..quot;); } Blockieren bis asynchrone Methode asynchron starten Methode beendet
  60. 60.  Ruft eine Methode asynchron nach Zeitspanne auf  Wiederholt Aufruf der Methode nach Zeitspanne  Timer.Change
  61. 61. Tick Intervall TimerCallbackDelegate Startverzögerung static void TestTimer() { Timer tm = new Timer(new TimerCallback(ThreadMethod), quot;Timerquot;, 0, 1000); Thread.Sleep(1000); tm.Change(0, 100); } Parameter Intervall / Verzögerung ändern
  62. 62.  Häufigster Anwendungsfall für Threading: Rechenlast aus GUIs auslagern  Dem Hauptthread möglichst wenig Rechenlast zuordnen  Rechenlast in Hauptthread verursacht hängende GUIs  Problematik: Zugriff auf Steuerelemente von Threads aus
  63. 63. private void cmdThreaded_Click(object sender, EventArgs e) { Thread FormsThread = new Thread(new ThreadStart(DoWork)); FormsThread.Start(); } private void cmdUnthreaded_Click(object sender, EventArgs e) { DoWork(); }
  64. 64. private void button1_Click(object sender, EventArgs e) { Thread FormsThread = new Thread(new ThreadStart(ManipulateList)); FormsThread.Start(); } private void ManipulateList() { listBox1.Items.Add(quot;testquot;); }
  65. 65.  Direktes Manipulieren von Windows Forms Steuerelementen löst Exception aus  Mit Invoke den UI Thread auffordern Manipulationen vorzunehmen  Delegaten übergeben  Asynchroner Aufruf ebenfalls möglich  Optional: Eine Methode für Invoke und Direkt mit InvokeRequired Eigenschaft
  66. 66. Delegat nach Funktion erstellen private delegate void ManipulateListDelegate(); private void ManipulateList() Invoke benötigt? { if (listBox1.InvokeRequired == true) { listBox1.Invoke(new ManipulateListDelegate(ManipulateList)); } Invoke aufrufen mit Verweis else auf Methode { listBox1.Items.Add(quot;testquot;); } } Manipulationen vornehmen

×