The Asynchronous Programming Model (APM), as implemented by Delegates, consists of three parts:  BeginInvoke, EndInvoke, and Rendezvous techniques.  BeginInvoke starts an algorithm, impelmented via a method, on a new thread.  EndInvoke retrieves the result of that method.  The Rendezvous techniques allow you to determine when the asynchronous operation has completed.

There are three different types of Rendezvous techniques you can use to retrieve the results of an asynchronous delegate invocation.  The first is Wait-Till-Completion, implemented via EndInvoke.  Calling this method will block the current thread until the results of the asynchronous method are available.  This is the least effective method, as it virtually eliminates the benefits of APM.

        private delegate string StringReturningDelegate();	// a delegate for a method that takes no params and returns a string

  
        private void Main()
        {

	    // create an instance of the delegate pointing to a method that takes ten seconds to complete
            StringReturningDelegate fd = new StringReturningDelegate(MethodThatTakes10SecondsToComplete);     

            // Begin invocation of this delegate

            IAsyncResult receipt = fd.BeginInvoke(null, null);

            // Immediately call EndInvoke, which will block for, oh, say, right about ten seconds
            string result = fd.EndInvoke(receipt);
            Console.Write(result);

	    Console.Read();
        }

	// A method that takes 10 seconds, then returns a string
        private string MethodThatTakes10SecondsToComplete() { Thread.Sleep(10000); return "Done!"; }

This code segment demonstrates Wait-Till-Completion.  You can see that it offers no benefits over calling MethodThatTakes10SecondsToComplete synchronously, as the EndInvoke method will block the calling thread.

The second Rendezvous technique is called Polling.  In this technique, you check a property of the IAsyncResult object called IsCompleted.  This property will return false until the async operation has completed.  The following code segment demonstrates polling on the same method:

        private delegate string StringReturningDelegate(); // a delegate for a method that takes no params and returns a string

        private void Main()

        {     

            // create an instance of the delegate pointing to a method that takes ten seconds to complete

            StringReturningDelegate fd = new StringReturningDelegate(MethodThatTakes10SecondsToComplete);

            // Begin invocation of this delegate            

	    IAsyncResult receipt = fd.BeginInvoke(null, null);

            // Poll IsCompleted until it returns true; Sleep the current thread between checks to reduce CPU usage

	    while(!receipt.IsCompleted)

	        Thread.Sleep(10);

            string result = fd.EndInvoke(receipt);

            Console.Write(result);

            Console.Read();

        }

        // A method that takes 10 seconds, then returns a string

        private string MethodThatTakes10SecondsToComplete() { Thread.Sleep(10000); return "Done!"; }

This method isn't much better.  You sleep away all the extra time that you could have been productive with (like in college). 

The third, and most efficient, Rendezvous technique is Method Callback.  In this technique, you pass a delegate to the BeginInvoke method that will be called when the asynchronous operation has completed.  It will not block your execution, or waste any CPU cycles.  You should always use this method of Rendezvous.

  
        private delegate string StringReturningDelegate(); // a delegate for a method that takes no params and returns a string 

        private void Main()        
        {                 
            // create an instance of the delegate pointing to a method that takes ten seconds to complete            
            StringReturningDelegate fd = new StringReturningDelegate(MethodThatTakes10SecondsToComplete);     
       
            // Begin invocation of this delegate                 
            fd.BeginInvoke(AsyncOpComplete, null);    

            // Do tons of work here.  No, seriously.
            Console.Read();        
        }

        /// <summary>
        /// Retrieves the results of MethodThatTakes10SecondsToComplete when called asynchronously
        /// </summary>
        /// <param name="receipt">The IAsyncResult receipt.</param>
        private void AsyncOpComplete(IAsyncResult receipt)
        {
            //  Cast to the actual object so that we can access the delegate
            AsyncResult result = (AsyncResult)receipt;

            //  retrieve the calling delegate
            StringReturningDelegate gsld = (StringReturningDelegate)result.AsyncDelegate;

            //  Retrieve our results; this is guaranteed not to block, as the async op is complete
            string result = gsld.EndInvoke(receipt);

            //  write the result to the console
            Console.Write(result);
        }

        // A method that takes 10 seconds, then returns a string        
        private string MethodThatTakes10SecondsToComplete() { Thread.Sleep(10000); return "Done!"; }

This method allows the program to continue execution while the async operation completes on another thread.  When the operation completes, the delegate will call the method AsyncOpComplete, which was passed to the delegate via the BeginInvoke method.

Take note that the implementation of MethodThatTakes10SecondsToComplete has not changed.  This is the major strength of the APM.  You create the method you wish to call asynchronously just as you would if it was to be used synchronously.  All the work required to call this method asynchronously is performed by the delegate.  All you have to do is create a delegate that matches the signature of your method, and construct a method (that returns void and takes one IAsyncResult parameter) designed to be run upon completion of the async operation.