Archive

Posts Tagged ‘APM’

Handling Causality with APM and Not ThreadPool QueueUserWorkItem

November 17, 2010 Leave a comment
using System;
using System.Runtime.Remoting.Messaging;

namespace AsynchronousProgrammingModelSamples
{

    public class ApmAsychExecution
    {
        public void ExecuteAsynchronouslyWithCallback<TResult>(Func<TResult> function, Action<TResult> callback,
                                                              Action<Exception> exception)
        {
            TResult result = default(TResult);

            Action action = () =>
                                {
                                    result = function();
                                };

            action.BeginInvoke(fn =>
                                  {

                                      try
                                      {
                                          AsyncResult aresult = (AsyncResult) fn;
                                          Action caller = (Action) aresult.AsyncDelegate;
                                          caller.EndInvoke(aresult);
                                          callback(result);
                                      }catch(Exception e)
                                      {
                                          exception(e);
                                      }
                                  }, null);

        }

        public void ExecuteAsynchronouslyWithCallback<TArg, TResult>(Func<TArg,TResult> function, Action<TResult> callback,
                                                              Action<Exception> exception, TArg argument)
        {
            TResult result = default(TResult);

            Action action = () =>
            {
                result = function(argument);
            };

            action.BeginInvoke(fn =>
            {

                try
                {
                    AsyncResult aresult = (AsyncResult)fn;
                    Action caller = (Action)aresult.AsyncDelegate;
                    caller.EndInvoke(aresult);
                    callback(result);
                }
                catch (Exception e)
                {
                    exception(e);
                }
            }, null);

        }
    }

    public class Customer
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public override string ToString()
        {
            return String.Format("Id: {0}, Name: {1}", Id, Name);
        }
    }

    public class Program
    {
        public static void Main()
        {
            Program p = new Program();
            p.ExecuteItemAsyncronously();

            Console.WriteLine("Press any key to quit..");
            Console.ReadKey();
        }

        public void ExecuteItemAsyncronously()
        {
            ApmAsychExecution apm = new ApmAsychExecution();
            apm.ExecuteAsynchronouslyWithCallback(
                    () => new Customer { Id = 1, Name = "Blair Davidson" }, Console.WriteLine, Console.WriteLine
                );
            apm.ExecuteAsynchronouslyWithCallback(
                    name => new Customer { Id = 1, Name = name }, Console.WriteLine, Console.WriteLine, "Patrick Smith"
                );
            apm.ExecuteAsynchronouslyWithCallback(
                    () =>
                        {
                            throw new InvalidOperationException("Error Testing....");
                            return new Customer {Id = 1, Name = "Blair Davidson"};
                        }, Console.WriteLine, Console.WriteLine
                );
        }
    }
}

Advertisements

APM Techniques with FileStream

November 17, 2010 Leave a comment
using System;
using System.IO;
using System.Linq;
using System.Text;

namespace AsynchronousProgrammingModelSamples
{
    public class Program
    {
        private string path = @"C:\test.txt";

        static void Main()
        {
            Program p = new Program();
            p.WriteContentsToFile();
           // p.ProcessLinesWithAPMUsingBlockWait();
           // p.ProcessLinesWithAPMUsingPolling();
            p.ProcessLinesWithAPMUsingCallbacks();
            Console.WriteLine("Press any key to quit..");
            Console.ReadKey();
        }

        public void ProcessLinesWithAPMUsingCallbacks()
        {
            FileStream stream = null;
            byte[] data = null;
            try
            {
                stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 1024, FileOptions.Asynchronous);
                data = new byte[stream.Length];
                stream.BeginRead(data, 0, data.Length, x =>
                                                           {
                                                               Console.WriteLine(Encoding.ASCII.GetString(data));
                                                           }, null);
            }
            catch (Exception e)
            {

            }
            finally
            {
                if (stream != null) stream.Close();
            }
        }

        public void ProcessLinesWithAPMUsingPolling()
        {
            FileStream stream = null;
            byte[] data = null;
            try
            {
                stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 1024, FileOptions.Asynchronous);
                data = new byte[stream.Length];
                IAsyncResult result = stream.BeginRead(data, 0, data.Length, null, null);

                while(!result.IsCompleted) // Pool and do something - Not a great way to do things 🙂
                {
                    Console.WriteLine("Waiting ....");
                }


                stream.EndRead(result);

                Console.WriteLine(Encoding.ASCII.GetString(data));

            }
            catch (Exception e)
            {

            }
            finally
            {
                if (stream != null) stream.Close();
            }
        }

        public void ProcessLinesWithAPMUsingBlockWait()
        {
            FileStream stream = null;
            byte[] data = null;
            try
            {
                stream = new FileStream(path,FileMode.Open,FileAccess.Read,FileShare.Read,1024,FileOptions.Asynchronous);
                data = new byte[stream.Length];
                IAsyncResult result = stream.BeginRead(data, 0, data.Length, null, null);

                stream.EndRead(result); // Basically we are blocking here util finished so no difference to the synch
                                        // version

                Console.WriteLine(Encoding.ASCII.GetString(data));

            }
            catch (Exception e)
            {

            }
            finally
            {
                if(stream != null) stream.Close();
            }
        }

        public void WriteContentsToFile()
        {
            var items = Enumerable.Range(1, 1000)
                                  .Select(x => x.ToString())
                                  .ToArray();

            var text = String.Join(Environment.NewLine, items);
            File.WriteAllText(path, text);

        }
    }
}

Blair…

APM and TPL – Reading Files

November 16, 2010 Leave a comment
using System;
using System.IO;
using System.Text;
using System.Threading.Tasks;

namespace APMExamples
{
    class Program
    {
        static void Main()
        {
            Program p = new Program();
            p.ReadFileContentsAsyncAndUseAContinuationToPrintResults();

            Console.WriteLine("Press any key to quit..");
            Console.ReadKey();

        }

        public void ReadFileContentsAsyncAndUseAContinuationToPrintResults()
        {
            var stream = new FileStream(@"C:\Projects\TPLSamples\TPLSamples.sln", FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 8 * 1024, FileOptions.Asynchronous);
            byte[] data = new byte[stream.Length];

            var t = Task<int>.Factory.FromAsync(stream.BeginRead, stream.EndRead, data, 0, data.Length, null);
            t.ContinueWith(x =>
                               {
                                   Console.WriteLine(Encoding.ASCII.GetString(data));
                                   stream.Close();
                               });
        }
    }
}