public override IAsyncResult BeginWrite(byte[] array, int offset, int numBytes, AsyncCallback userCallback, object stateObject);

public override void Write(byte[] array, int offset, int count);

public override void EndWrite(IAsyncResult asyncResult);

public class AsyncDemo

{

    // The delegate must have the same signature as the method

    // it will call asynchronously.

    public delegate string AsyncMethodCaller(int callDuration, out int threadId);

    // The method to be executed asynchronously.

    public string TestMethod(int callDuration, out int threadId)

    {

        Console.WriteLine("Test method begins.");

        Thread.Sleep(callDuration);

        threadId = Thread.CurrentThread.ManagedThreadId;

        return String.Format("My call time was {0}.", callDuration.ToString());

    }

}

using System;

using System.Threading;

using AsynchronousOperations;

namespace UseEndInvokeToWaitAsyncCall

{

    class Program

    {

        static void Main(string[] args)

        {

            // The asynchronous method puts the thread id here.

            int threadId;

            // Create an instance of the test class.

            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.

            AsyncDemo.AsyncMethodCaller caller = new AsyncDemo.AsyncMethodCaller(ad.TestMethod);

            // Initiate the asychronous call.

            IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null);

            Thread.Sleep(0);

            Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId);

            // Call EndInvoke to wait for the asynchronous call to complete,

            // and to retrieve the results.

            string returnValue = caller.EndInvoke(out threadId, result);

            Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".", threadId, returnValue);

            Console.WriteLine("Press any Key to Exit.");

            Console.ReadKey();

        }

    }

}

//This example produces output similar to the following:

//Main thread 10 does some work.

//Test method begins.

//The call executed on thread 6, with return value "My call time was 3000.".

//Press any Key to Exit.

using System;

using System.Threading;

using AsynchronousOperations;

namespace UseWaiHandleToWaitAsyncCall

{

    class Program

    {

        static void Main(string[] args)

        {

            // The asynchronous method puts the thread id here.

            int threadId;

            // Create an instance of the test class.

            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.

            AsyncDemo.AsyncMethodCaller caller = new AsyncDemo.AsyncMethodCaller(ad.TestMethod);

            // Initiate the asychronous call.

            IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null);

            Thread.Sleep(0);

            Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId);

            // Wait for the WaitHandle to become signaled.

            result.AsyncWaitHandle.WaitOne();

            // Perform additional processing here.

            // Call EndInvoke to retrieve the results.

            string returnValue = caller.EndInvoke(out threadId, result);

            // Close the wait handle.

            result.AsyncWaitHandle.Close();

            Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".", threadId, returnValue);

            Console.WriteLine("Press any Key to Exit.");

            Console.ReadKey();

        }

    }

}

//This example produces output similar to the following:

//Main thread 8 does some work.

//Test method begins.

//The call executed on thread 9, with return value "My call time was 3000.".

//Press any Key to Exit.

using System;

using System.Threading;

using AsynchronousOperations;

namespace PollUntilAsyncComplete

{

    class Program

    {

        static void Main(string[] args)

        {

            // The asynchronous method puts the thread id here.

            int threadId;

            // Create an instance of the test class.

            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.

            AsyncDemo.AsyncMethodCaller caller = new AsyncDemo.AsyncMethodCaller(ad.TestMethod);

            // Initiate the asychronous call.

            IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null);

            // Poll while simulating work.

            while (result.IsCompleted == false)

            {

                Thread.Sleep(250);

                Console.Write(".");

            }

            // Call EndInvoke to retrieve the results.

            string returnValue = caller.EndInvoke(out threadId, result);

            Console.WriteLine("\nThe call executed on thread {0}, with return value \"{1}\".", threadId, returnValue);

            Console.WriteLine("Press any Key to Exit.");

            Console.ReadKey();

        }

    }

}

//This example produces output similar to the following:

//Test method begins.

//............

//The call executed on thread 10, with return value "My call time was 3000.".

//Press any Key to Exit.

using System;

using System.Runtime.Remoting.Messaging;

using System.Threading;

using AsynchronousOperations;

namespace WhenAsyncIsCompletedRunAsyncCallback

{

    class Program

    {

        static void Main(string[] args)

        {

            // Create an instance of the test class.

            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.

            AsyncDemo.AsyncMethodCaller caller = new AsyncDemo.AsyncMethodCaller(ad.TestMethod);

            // The threadId parameter of TestMethod is an out parameter, so

            // its input value is never used by TestMethod. Therefore, a dummy

            // variable can be passed to the BeginInvoke call. If the threadId

            // parameter were a ref parameter, it would have to be a class-

            // level field so that it could be passed to both BeginInvoke and 

            // EndInvoke.

            int dummy = 0;

            // Initiate the asynchronous call, passing three seconds (3000 ms)

            // for the callDuration parameter of TestMethod; a dummy variable 

            // for the out parameter (threadId); the callback delegate; and

            // state information that can be retrieved by the callback method.

            // In this case, the state information is a string that can be used

            // to format a console message.

            IAsyncResult result = caller.BeginInvoke(3000,

                out dummy,

                new AsyncCallback(CallbackMethod),

                "The call executed on thread {0}, with return value \"{1}\".");

            Console.WriteLine("The main thread {0} continues to execute...", Thread.CurrentThread.ManagedThreadId);

            // The callback is made on a ThreadPool thread. ThreadPool threads

            // are background threads, which do not keep the application running

            // if the main thread ends. Comment out the next line to demonstrate

            // this.

            Thread.Sleep(4000);

            Console.WriteLine("The main thread ends.");

            Console.WriteLine("Press any Key to Exit.");

            Console.ReadKey();

        }

        // The callback method must have the same signature as the

        // AsyncCallback delegate.

        static void CallbackMethod(IAsyncResult ar)

        {

            // Retrieve the delegate.

            AsyncResult result = (AsyncResult)ar;

            AsyncDemo.AsyncMethodCaller caller = (AsyncDemo.AsyncMethodCaller)result.AsyncDelegate;

            // Retrieve the format string that was passed as state 

            // information.

            string formatString = (string)ar.AsyncState;

            // Define a variable to receive the value of the out parameter.

            // If the parameter were ref rather than out then it would have to

            // be a class-level field so it could also be passed to BeginInvoke.

            int threadId = 0;

            // Call EndInvoke to retrieve the results.

            string returnValue = caller.EndInvoke(out threadId, ar);

            // Use the format string to format the output message.

            Console.WriteLine(formatString, threadId, returnValue);

        }

    }

}

//This example produces output similar to the following:

//Test method begins.

//The main thread 9 continues to execute...

//The call executed on thread 6, with return value "My call time was 3000.".

//The main thread ends.

//Press any Key to Exit.