c# wpf print barcode Lesson 2: Implementing Asynchronous Methods in .NET

Printer QR in .NET Lesson 2: Implementing Asynchronous Methods

first thread might add an Object to the collection. The second thread might then remove an object from the collection based on the index of the object. The first thread then might attempt to access the object in the collection to find that it had been removed. Race conditions can lead to unpredictable effects that can destabilize your application. The best way to avoid race conditions and deadlocks is by careful programming and judicious use of thread synchronization. You can use the SyncLock keyword in Visual Basic and the lock keyword in C# to obtain an exclusive lock on an object. This allows the thread that has the lock on the object to perform operations on that object with out allowing any other threads to access it. Note that if any other threads attempt to access a locked object, those threads will pause until the lock is released. The follow ing example demonstrates how to obtain a lock on an object:

' VB SyncLock anObject ' Perform some operation End SyncLock // C# lock (anObject) { // Perform some operation }

Some objects, such as collections, implement a synchronization object that should be used to synchronize access to the greater object. The following example demonstrates how to obtain a lock on the SyncRoot object of an ArrayList object.

' VB Dim anArrayList As New System.Collections.ArrayList SyncLock anArrayList.SyncRoot ' Perform some operation on the ArrayList End SyncLock // C# lock (anArrayList.SyncRoot) { // Perform some operation on the ArrayList }

It is generally good practice when creating classes that will be accessed by multiple threads to include a synchronization object that is used for synchronized access to threads. This allows the system to lock only the synchronization object, thus conserv ing resources by not having to lock every single object contained in the class. A syn chronization object is simply an instance of Object and does not need to have any

13

functionality except to be available for locking. The following example demonstrates a class that exposes a synchronization object.

Public SynchronizationObject As New Object()

public object SynchronizationObject = new Object();

Because controls are always owned by the UI thread, it is generally unsafe to make calls to controls from a different thread. You can use the Control.InvokeRequired prop erty to determine if it is safe to make a call to a control from another thread. If InvokeRequired returns False, it is safe to make the call to the control. If InvokeRequired returns True, however, you should use the Control.Invoke method on the owning form to supply a delegate to a method to access the control. Using Control.Invoke allows the control to be accessed in a thread-safe manner. The following example demonstrates setting the Text property of a TextBox control named Text1.

' VB Public Delegate Sub SetTextDelegate(ByVal t As String)

Public Sub SetText(ByVal t As String)

Dim del As New SetTextDelegate(AddressOf SetText)

Me.Invoke(del, New Object() {t})

// C# public delegate void SetTextDelegate(string t);

public void SetText(string t)

if (textBox1.InvokeRequired) {

SetTextDelegate del = new SetTextDelegate(SetText);

this.Invoke(del, new object[]{t});

textBox1.Text = t; } }

In the preceding example, the method tests InvokeRequired to determine if it is dan gerous to access the control directly. In general, this will return True if the control is being accessed from a separate thread. If InvokeRequired does return True, the method creates a new instance of a delegate that refers to itself and calls Control.Invoke to set the Text property in a thread-safe manner.

1. What is a delegate How is a delegate used 2. What is thread synchronization and why is it important

1. A delegate is a type-safe function pointer. It contains a reference to the entry point of a method and can be used to invoke that method. A delegate can be used to invoke a method synchronously, or asynchronously on a sepa rate thread. 2. When working with multiple threads of execution, problems can occur if multiple threads attempt to access the same resources. Thread synchroni zation is the process of ensuring that threads do not attempt to access the same resource at the same time. One way to synchronize threads is to obtain exclusive locks on the objects you wish to access, thereby prohibit ing other threads from affecting them at the same time.