code 128 c# font Reset in Visual C#.NET

Encoding Code 128A in Visual C#.NET Reset

Reset is a method of the AutoResetEvent class that changes the state of an instance of that class to unsignaled. Calling the method is generally not required since the release of a thread from the WaitSleepJoin state automatically changes the state of AutoResetEvent to unsignaled.

The constructor of AutoResetEvent contains a parameter that controls the initial state of the instance of the class. If False is passed in, the instance of the AutoResetEvent class is initially unsignaled. If True is passed in, it is initially signaled. Listing 8.1 demonstrates the Set method of the AutoResetEvent class.

Listing 8.1 Using WaitOne and Set to update the display (VB.NET)

Private UpdateUIEvent As AutoResetEvent . . . UpdateUIEvent = New AutoResetEvent(False) . . . Dim M1 As ClassSimpleMatrix

Dim M2 As ClassSimpleMatrix Dim M1Cols, M1Rows As Long Dim M2Cols, M2Rows As Long . . . M1 = New ClassSimpleMatrix(M1Cols, M1Rows) M2 = New ClassSimpleMatrix(M2Cols, M2Rows) M1.Randomize(100) M2.Randomize(100) Change to M3 = M1.Multiply(M2) signaled UpdateUIEvent.Set() . . . Wait until Private Sub UpdateUI() UpdateUIEvent.Set While (True) is called UpdateUIEvent.WaitOne() If Not M3 Is Nothing Then If (listView1.InvokeRequired) Then Dim args As Object() = {listView1, M3} Dim updateit As ListViewUpdater updateit = AddressOf UpdateListViewWithMatrix listView1.Invoke(updateit, args) Else UpdateListViewWithMatrix(listView1, M3) End If End If End While End Sub

Since the AutoResetEvent class is derived from the WaitHandle class it is important to understand the methods of WaitHandle. Section 8.3 discusses the WaitHandle class in detail.

WaitHandle is an abstract base class. This means that no instance of it can be created. Classes that are derived from WaitHandle can be created, assuming they are not abstract base classes themselves. In section 8.2 we discussed one class that is derived from WaitHandle, the AutoResetEvent class. In this section we discuss three of the methods of the WaitHandle class: WaitOne, WaitAll, and WaitAny.

WaitOne is used to wait for a class that s derived from WaitHandle to reach a signaled state. In the last section we covered one way AutoResetEvent, which is derived from WaitHandle, becomes signaled.

WaitOne is an instance method of all classes derived from WaitHandle. It attempts to put the instance of the object it is associated with into the WaitSleepJoin state. If it is successful it returns true; otherwise, it returns false. A timeout value can optionally be included.

WaitOne returns a Boolean value that indicates it is signaled. In the case where WaitOne is invoked with no parameters, it will always return true because it blocks

until it becomes signaled. If it returns, it must have been signaled. So in the next example ReceivedSignal will always be true:

Bool ReceivedSignal = TheEvent.WaitOne();

The other versions of WaitOne accept two parameters. The first parameter is a timeout value, either an integer or a TimeSpan object. If it is an integer, the value indicates how many milliseconds to wait. If the instance of AutoResetEvent becomes signaled before the timeout period WaitOne will return true.

The exitContext parameter of WaitOne controls how the method behaves when invoked from within a synchronized context. If WaitOne is invoked in a synchronized context and the exitContext parameter is not true, deadlock will likely occur.

The second parameter, exitContext, to the timed-out version of WaitOne is a Boolean that controls how WaitOne behaves when it is invoked from within a synchronized context. If the second parameter is false, WaitOne behaves the same as it does when it is called with no parameters, except a timeout value can be specified. If the exitContext parameter is true and the WaitOne method is invoked from within a synchronized context, the context is exited before the thread enters the WaitSleepJoin state. The context is then reentered when the thread exits the WaitSleepJoin state. Unless the COM+ approach to synchronization is being used, there is no reason to be concerned with this parameter. If the Synchronization attribute is being used on the class, then the value should be set to true.

Listing 8.2 Specifying if the current context should be exited before the wait begins (C#)

private void ThreadMethod() { try { bool ReceivedSignal; for (int i=0;i<10;i++) { // ExitContext is true == Deadlock ReceivedSignal =TheEvent.WaitOne(2000,ExitContext); if (ReceivedSignal) Exit the context { before the wait Console.WriteLine("received signal" ); begins }