Asynchronous Delegates Programming Sample

The following code example demonstrates the use of .NET asynchronous programming using a class that factorizes some numbers. This example defines a class with a single method Factorize that computes the prime factors of a specified number. The example also defines a delegate named AsyncFactorCaller with a signature that matches the signature of the Factorize method. The delegate is used by methods in the DemonstrateAsyncPattern class to call the Factorize method asynchronously. The FactorizeNumberUsingCallback method demonstrates using an AsyncCallback delegate to end the asynchronous operation and get the results. The FactorizeNumberAndWait method demonstrates periodic polling to determine whether the operation has completed.

Example

Imports System
Imports System.Threading
Imports System.Runtime.Remoting.Messaging

Namespace Examples.AdvancedProgramming.AsynchronousOperations

    ' Create a class that factors a number. 
    Public Class PrimeFactorFinder
       Public Shared Function Factorize( _
                    ByVal number as Integer, _
                    Byref primefactor1 as Integer, _
                    Byref primefactor2 as Integer) as Boolean
          primefactor1 = 1
          primefactor2 = number

          ' Factorize using a low-tech approach. 
          For i as Integer =2 To number-1
             If 0 =  (number MOD i)
                primefactor1 = i
                primefactor2 = number / i
                Exit For 
             End If 
          Next i
          If 1 = primefactor1
             Return False 
          Else 
             Return True 
          End If 
       End Function 
    End Class 

    ' Create an asynchronous delegate that matches the Factorize method. 
    Public delegate Function AsyncFactorCaller ( _
             number as Integer, _
             ByRef primefactor1 as Integer, _
             ByRef primefactor2 as Integer) as Boolean 

    Public Class DemonstrateAsyncPattern
              ' The waiter object is used to keep the main application thread 
              ' from terminating before the callback method completes. 
              Dim waiter as ManualResetEvent 
        ' Define the method that is invoked when the results are available. 
        Public Sub FactorizedResults(result as IAsyncResult)
              Dim factor1 as Integer =0
              Dim factor2 as Integer =0

              ' Extract the delegate from the  
              ' System.Runtime.Remoting.Messaging.AsyncResult. 
              Dim ar as AsyncResult = CType (result, AsyncResult)
              Dim delegateObject as Object = ar.AsyncDelegate
              Dim factorDelegate as AsyncFactorCaller =  _
                    CType(delegateObject, AsyncFactorCaller)

              Dim number as Integer = CType(result.AsyncState, Integer)
              Dim answer as Boolean 

              ' Obtain the result.
              answer = factorDelegate.EndInvoke(factor1, factor2, result)
              ' Output the results.
              Console.WriteLine("On CallBack: Factors of {0} : {1} {2} - {3}", _
                  number, factor1, factor2, answer)
             waiter.Set()
           End Sub 

       ' The following method demonstrates the asynchronous pattern using a callback method. 
       Public Sub FactorizeNumberUsingCallback()
          Dim  factorDelegate as AsyncFactorCaller
          Dim result as IAsyncResult
          Dim callback as AsyncCallback
          Dim number as Integer = 1000589023
          Dim temp as Integer = 0 

         ' Waiter will keep the main application thread from  
         '' ending before the callback completes because 
         ' the main thread blocks until the waiter is signaled 
         ' in the callback.
          waiter = new ManualResetEvent(False)
          factorDelegate = AddressOf PrimeFactorFinder.Factorize
          ' Define the AsyncCallback delegate.
          callBack = new AsyncCallback (AddressOf FactorizedResults)

          ' Asynchronously invoke the Factorize method.
          result = factorDelegate.BeginInvoke( _
                               number, _
                               temp, _
                               temp, _
                               callBack, _
                               number) 
       End Sub 

       ' The following method demonstrates the asynchronous pattern  
       ' using a BeginInvoke, followed by waiting with a time-out. 
       Public Sub FactorizeNumberAndWait()
           Dim factorDelegate as AsyncFactorCaller
           Dim result as IAsyncResult

           factorDelegate = AddressOf PrimeFactorFinder.Factorize

          Dim number as Integer = 1000589023
          Dim temp as Integer = 0 

          ' Asynchronously invoke the Factorize method.
          result = factorDelegate.BeginInvoke( _
                            number, _
                            temp, _ 
                            temp, _
                            Nothing, _
                            Nothing) 

          Do While result.IsCompleted = False 
            ' Do any work you can do before waiting.
            result.AsyncWaitHandle.WaitOne(10000, false)
          Loop
          result.AsyncWaitHandle.Close()

          ' The asynchronous operation has completed. 
          Dim factor1 as Integer = 0
          Dim factor2 as Integer = 0
          Dim answer as Boolean 
          ' Obtain the result.
          answer = factorDelegate.EndInvoke(factor1, factor2, result)

         ' Output the results.
         Console.WriteLine("Sequential : Factors of {0} : {1} {2} - {3}", _ 
                           number, factor1, factor2, answer)
       End Sub 

       Public Shared Sub Main()
          Dim  demonstrator as DemonstrateAsyncPattern
          demonstrator = new DemonstrateAsyncPattern()
          demonstrator.FactorizeNumberUsingCallback()
          demonstrator.FactorizeNumberAndWait()
       End Sub 
    End Class 
End Namespace
using System;
using System.Threading;
using System.Runtime.Remoting.Messaging;

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    // Create a class that factors a number. 
    public class PrimeFactorFinder
    {
       public static bool Factorize(
                    int number,
                    ref int primefactor1,
                    ref int primefactor2)
       {
          primefactor1 = 1;
          primefactor2 = number;

          // Factorize using a low-tech approach. 
          for (int i=2;i<number;i++)
          {
             if (0 == (number % i))
             {
                primefactor1 = i;
                primefactor2 = number / i;
                break;
             }
          }
          if (1 == primefactor1 )
             return false;
          else 
             return true   ;
       }
    }

    // Create an asynchronous delegate that matches the Factorize method. 
    public delegate bool AsyncFactorCaller (
             int number, 
             ref int primefactor1,
             ref int primefactor2);

    public class DemonstrateAsyncPattern
    {
        // The waiter object used to keep the main application thread 
        // from terminating before the callback method completes.
        ManualResetEvent waiter;

        // Define the method that receives a callback when the results are available. 
        public void FactorizedResults(IAsyncResult result)
           {
              int factor1=0;
              int factor2=0; 

              // Extract the delegate from the  
              // System.Runtime.Remoting.Messaging.AsyncResult.
              AsyncFactorCaller factorDelegate = (AsyncFactorCaller)((AsyncResult)result).AsyncDelegate;
              int number = (int) result.AsyncState;
              // Obtain the result. 
              bool answer = factorDelegate.EndInvoke(ref factor1, ref factor2, result);
              // Output the results.
              Console.WriteLine("On CallBack: Factors of {0} : {1} {2} - {3}", 
                  number, factor1, factor2, answer);
              waiter.Set();
           }

       // The following method demonstrates the asynchronous pattern using a callback method. 
       public void FactorizeNumberUsingCallback()
       {
          AsyncFactorCaller factorDelegate = new AsyncFactorCaller (PrimeFactorFinder.Factorize);
          int number = 1000589023;
          int temp=0; 
          // Waiter will keep the main application thread from  
          // ending before the callback completes because 
          // the main thread blocks until the waiter is signaled 
          // in the callback.
           waiter = new ManualResetEvent(false);

          // Define the AsyncCallback delegate.
          AsyncCallback callBack = new AsyncCallback(this.FactorizedResults);

          // Asynchronously invoke the Factorize method.
          IAsyncResult result = factorDelegate.BeginInvoke(
                               number, 
                               ref temp, 
                               ref temp, 
                               callBack, 
                               number); 

          // Do some other useful work while  
          // waiting for the asynchronous operation to complete. 

          // When no more work can be done, wait.
          waiter.WaitOne();
       }

       // The following method demonstrates the asynchronous pattern  
       // using a BeginInvoke, followed by waiting with a time-out. 
       public void FactorizeNumberAndWait()
       {
          AsyncFactorCaller factorDelegate = new AsyncFactorCaller (PrimeFactorFinder.Factorize);

          int number = 1000589023;
          int temp=0; 

          // Asynchronously invoke the Factorize method.
          IAsyncResult result = factorDelegate.BeginInvoke(
                            number, 
                            ref temp, 
                            ref temp, 
                            null, 
                            null); 

          while (!result.IsCompleted)
          {
            // Do any work you can do before waiting.
            result.AsyncWaitHandle.WaitOne(10000, false);
          }
          result.AsyncWaitHandle.Close();

          // The asynchronous operation has completed. 
          int factor1=0;
          int factor2=0; 

         // Obtain the result. 
         bool answer = factorDelegate.EndInvoke(ref factor1, ref factor2, result);

         // Output the results.
         Console.WriteLine("Sequential : Factors of {0} : {1} {2} - {3}", 
                           number, factor1, factor2, answer);
       }

       public static void Main()
       {
          DemonstrateAsyncPattern demonstrator = new DemonstrateAsyncPattern();
          demonstrator.FactorizeNumberUsingCallback();
          demonstrator.FactorizeNumberAndWait();
       }
    }
}

Change History

Date

History

Reason

September 2010

Added code to close the wait handle.

Customer feedback.