Javier Arguello (javarg)

CodedUI: Close Dialogs and Windows

javarg — Sat, 28 Jan 2012 03:05:28 GMT

UI automation could be a very very complex procedure. Several things could change between different executions, controls could be moved or renamed, etc.

Some simple things such as closing a dialog popup/window could be challenging..

Let’s try to recreate the problem. File/New Project in Visual Studio 2010, then select Windows Forms.

Add a button with the following handler on the click event:

MessageBox
private void button1_Click(object sender, EventArgs e)
 {
     MessageBox.Show("Try closing me..", "Try closing me..", MessageBoxButtons.OKCancel);
 }

Record a CodedUI test that opens our super simple WinForm App, click Button1 and then close the message box. Finally, add one last step to record that closes the Main Window.

Now run the previous CodeUI test and check how the test reports a successful execution. Note that your Message Box is still opened and your application is still waiting for input.

* I imagine that it should be a better way of working around this effect than the following. If you figure it out let me know :).

Let’s create a UIMapExtensions class (containing extensions methods of course)

UIMapExtensions
public static class UIMapExtensions
 {
     public delegate void CloseTestControlCallback();
 
     public static bool CloseWindow(this UITestControl testControl, CloseTestControlCallback closeCallback)
     {
         var closeSuccess =
             testControl.WaitForControlCondition(
                 tc =>
                 {
                     closeCallback();
                     return !tc.Exists;
                 }, 3000);
         return closeSuccess;
     }
 
     public static bool CancelDialog(this UITestControl testControl)
     {
         var closeSuccess =
             testControl.WaitForControlCondition(
                 tc =>
                 {
                     Keyboard.SendKeys("{ESC}");
                     return !tc.Exists;
                 }, 3000);
         return closeSuccess;
     }
 
     public static bool AcceptDialog(this UITestControl testControl)
     {
         var closeSuccess =
             testControl.WaitForControlCondition(
                 tc =>
                 {
                     Keyboard.SendKeys("{ENTER}");
                     return !tc.Exists;
                 }, 3000);
         return closeSuccess;
     }
 
     public static bool CloseWindow(this UITestControl testControl)
     {
         var closeSuccess =
             testControl.WaitForControlCondition(
                 tc =>
                 {
                     WinApi.PostMessage(tc.WindowHandle, WinApi.WM_CLOSE, 0, 0);
                     return !tc.Exists;
                 }, 3000);
         return closeSuccess;
     }
 }

I am using 3 techniques in the previous code fragment. In each one of them, we wait for the control to respond to the close action (for 3000 ms).

CloseWindow that receives a delegate to the close action. You can pass in the original Close method generated by the UIMap as you will see in the Test Method code below.
CloseWindow with no arguments using PostMessage Win API and P/Invoke (this is some how brute force :)).
AcceptDialog and CancelDialog: assuming it is a message box with Ok/Cancel buttons and that the window is in the foreground.

Now you can just replace some of generated test code in the Test Class (not in the UIMap):

Test Method
[TestMethod]
 public void CodedUITestMethod1()
 {
     this.UIMap.OpenApplication();
     this.UIMap.OpenPopup();
     //this.UIMap.ClosePopup();
 
     // try one of the following..
     var closeSuccess = this.UIMap.UItryclosingmeWindow.CloseWindow(this.UIMap.ClosePopup);
     //var closeSuccess = this.UIMap.UItryclosingmeWindow.AcceptDialog();
     //var closeSuccess = this.UIMap.UItryclosingmeWindow.CancelDialog();
     //var closeSuccess = this.UIMap.UItryclosingmeWindow.CloseWindow();
     if (!closeSuccess)
         Assert.Fail("Popup not closed!");
 
     this.UIMap.CloseApplication();
 }

My two cents..

TFS Build 2010: BuildNumber and DropLocation

javarg — Fri, 18 Nov 2011 00:38:38 GMT

Automatic Builds for Application Release is a current practice in every major development factory nowadays.

Using Team Foundation Server Build 2010 to accomplish this offers many opportunities to improve quality of your releases.

The following approach allow us to generate build drop folders including the BuildNumber and the Changeset or Label provided. Using this procedure we can quickly identify the generated binaries in the Drop Server with the corresponding Version.

Branch the DefaultTemplate.xaml and renamed it with CustomDefaultTemplate.xaml

Open it for edit (check out)
Go to the Set Drop Location Activity and edit the DropLocation property.

Write the following expression:

BuildDetail.DropLocationRoot + "\" + BuildDetail.BuildDefinition.Name + "\" + If(String.IsNullOrWhiteSpace(GetVersion), BuildDetail.SourceGetVersion, GetVersion) + "_" + BuildDetail.BuildNumber

Check in the branched template.
Now create a build definition named TestBuildForDev using the new template.

The previous expression sets the DropLocation with the following format: (ChangesetNumber|LabelName)_BuildName_BuildNumber

The first part of the folder name will be the changeset number or the label name (if triggered using labels). Folder names will be generated as following:

C1850_TestBuildForDev_20111117.1 (changesets start with letter C)
LLabelname_TestBuildForDev_20111117.1 (labels start with letter L)

Try launching a build from a Changeset and from a Label. You can specify a Label in the GetVersion parameter in the Queue new Build Wizard, going to the Parameters tab (for labels add the “L” prefix):

Evento Gratuito de Arquitectura / Architecture Event

javarg — Thu, 17 Nov 2011 23:30:00 GMT

El próximo 29 de noviembre voy a participar como orador en Microsoft en este evento gratuito sobre Herramientas de desarrollo y patrones de Arquitectura. Vamos a tomar varios temas interesantes sobre Arquitectura y construcción de Frameworks de Desarrollo.

Si están interesados en asistir, se pueden comunicar conmigo a través de un comentario en este blog o registrarse aquí.

English: Next November 29th I will be participating as a speaker in a free admission event at Microsoft México offices. We will be discussing very interesting topics about Architecture and the development of Technical Frameworks.

Load Test in Windows Azure with Visual Studio Test Agents

javarg — Mon, 23 May 2011 01:12:04 GMT

Tomorrow I will be presenting “Load Test in Windows Azure with Visual Studio Test Agents” on MSDN. Hope to see you there.

Using Moles with DLR (dynamic)

javarg — Tue, 26 Apr 2011 19:13:00 GMT

As several people have found, Moles does not work well with DLR. Check Cameron’s post for this issue.

In order to make it work do the following:

Go to folder C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\PrivateAssemblies\
Backup files Microsoft.Moles.VsHost.exe.Config / Microsoft.Moles.VsHost.x86.exe.Config (depending on your application’s platform)
Modify the starup element and set the useLegacyV2RuntimeActivationPolicy to false in the .config file.
Modify the legacyCasPolicy element and set the enabled to false the .config file.

Microsoft.Moles.VsHost.x86.exe
<?xml version="1.0" encoding="utf-8" ?>
 <configuration>
   <startup useLegacyV2RuntimeActivationPolicy="false">
     <supportedRuntime version="v4.0" />
     <supportedRuntime version="v2.0.50727" />
   </startup>
   <runtime>
      <legacyCasPolicy enabled="false" />
   </runtime>
 </configuration>

I haven’t done further testing on changing the use of legacy CAS Policy when using Moles & VS Test Framework.

Let me know how it works for you.

Moles and Linq to SQL: Mocking Linq to SQL Behavior

javarg — Tue, 26 Apr 2011 15:21:38 GMT

In recent years there’s been major investments in developing tools in order to provide good quality assurance features and incorporate industry practices into them.

TDD, DDD, Unit Testing, Continuous Integration, etc.

Microsoft has recently (not so recently actually :)) ship some very nice features to help us improve our code quality by allowing us to create better tests over units of code.

Unit testing is all about proving individual units of code (positive and negative testing). Since a great deal of software is not always designed with this “unit independence” in mind, it can be a challenge to isolate dependencies for every piece of source code (specially legacy code).

Moles is an Isolation Framework that mocks/emulates the behavior of our components and external libraries, even for private members. You could even mock how a particular System.* class object in .NET behaves (check Pex & Moles site in Microsoft Research).

The following is a Repository object that uses Linq to Sql Data Context internally and doesn't provide a simple way of decoupling database access from its behavior. It means we cannot unit test the following class without a SQL database.

Customer Repository
public class CustomerRepository
 {
     public IList<Customer> GetCustomers()
     {
         using (var db = new AdventureWorksDataContext())
         {
             return db.Customers.ToList();
         }
     }
 
     public Customer GetCustomer(int id)
     {
         using (var db = new AdventureWorksDataContext())
         {
             return db.Customers.FirstOrDefault(c => c.CustomerID == id);
         }
     }
 }

By using Moles, we could replace inner behavior of this class.

Note: This is White Box Testing, meaning you need to have access to internal implementation in order to know how to mock it.

Mocking with Moles

Download and install Moles.

Add Mole Assemblies for the project hosting the previous class (or the code you wish to test)
Add Mole Assembly for System.Data.Linq
Add Mole Assembly for System.Core

Check this tutorial about Pex & Moles for more information about the previous steps.

The following code fragment unit test our GetCustomers method:

Overriding Enumeration
[TestMethod()]
 [HostType("Moles")]
 public void GetCustomersTest()
 {
     System.Data.Linq.Moles.MTable<Customer>.AllInstances.GetEnumerator =
         tc =>
         {
             var mockCustomers = new List<Customer>() 
             {
                 new Customer() { FirstName = "Javier" },
                 new Customer() { FirstName = "Jorge" },
                 new Customer() { FirstName = "Dario" } 
             };
 
             return mockCustomers.GetEnumerator();
         };
 
     CustomerRepository target = new CustomerRepository();
     var customers = target.GetCustomers();
     Assert.IsNotNull(customers);
     Assert.IsTrue(customers.Count == 3);
     Assert.AreEqual("Javier", customers[0].FirstName);
 }

Check out the use of Moles to specify the behavior of enumeration for the Table<Customer> (Customers) that Linq to Sql Provider uses to execute the query in the database. In the previous code, we avoid querying data from database and return an in-memory list of customers.

When executing a lambda expression using Linq to Sql, the source Linq provider must interpret the query and then issue a command to the database.

In order to intercept the query and return mock results, we must override default behavior for the expression evaluation logic of the Linq Provider.

Overriding Expression Eval
[TestMethod()]
 [HostType("Moles")]
 public void GetCustomerTest()
 {
     var expectedCustomer = new Customer() { FirstName = "Javier", CustomerID = 1 };
 
     System.Data.Linq.Moles.MTable<Customer>.AllInstances.ProviderSystemLinqIQueryableget =
         tc =>
         {
             var qp = new System.Linq.Moles.SIQueryProvider();
             qp.ExecuteExpression01(exp => expectedCustomer);
             return qp;
         };
 
     CustomerRepository target = new CustomerRepository();
 
     var actualCustomer = target.GetCustomer(expectedCustomer.CustomerID);
     Assert.IsNotNull(actualCustomer);
     Assert.AreEqual(expectedCustomer.CustomerID, actualCustomer.CustomerID);
     Assert.AreEqual(expectedCustomer.FirstName, actualCustomer.FirstName);
 }

The previous mocking code returns a Mock QueryProvider that does not evaluate the expression, it simply returns the in-memory customer reference.

I encourage you that read more about Moles here.

PS: This cool framework intercepts any managed operation by creating a CLR Host for the application.

Visual Studio 2010 crashes with “Exception has been thrown by the target of an invocation”

javarg — Mon, 25 Apr 2011 13:51:13 GMT

If you haven´t installed Visual Studio 2010 SP1 yet and you’ve enabled automatic Windows Update, chances are you end up getting the following error when starting VS2010: Exception has been thrown by the target of an invocation.

There is a .NET 4 Framework in Windows update distributed recently that generates this conflict.

Solution: Install VS2010 Sp1.

Webcast MSDN: Parallel LINQ

javarg — Mon, 25 Apr 2011 03:49:00 GMT

Next Wednesday (April 27th) I will presenting Parallel LINQ and showing some not trivial stuff to optimize performance in parallel algorithms. Register here.

.NET Community Mexico City

javarg — Mon, 25 Apr 2011 03:30:00 GMT

I will be participating as an invited speaker in “Comunidad.NET” in Mexico City next Tuesday (April 26th). My presentation will be focusing code quality using Visual Studio Tools.

Agenda:

Code Metrics
Code Analysis
Profiling
IntelliTrace
Pex & Moles

You can get more info from Raul’s blog.

Async C# 5: Using Async Pattern with WCF and Silverlight

javarg — Wed, 13 Apr 2011 02:30:19 GMT

Sometime ago I published a way to use WCF service with the new Async Pattern in C#. The problem is that this approach won’t work with Silverlight. More specifically, TaskFactory is not available in Silverlight.

So.. here is one solution (it does not provide full functionality as in TaskFactory, but you can manage 90% of use cases):

MyTaskFactory
public static class MyTaskFactory
 {
     public static Task<TResult> FromAsync<TResult>(
         IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod)
     {
         var completionSource = new TaskCompletionSource<TResult>();
         if (asyncResult.IsCompleted)
         {
             completionSource.TrySetResult(asyncResult, endMethod);
         }
         else
         {
             System.Threading.ThreadPool.RegisterWaitForSingleObject(
                 asyncResult.AsyncWaitHandle,
                 (state, timeOut) =>
                 {
                     completionSource.TrySetResult(asyncResult, endMethod);
                 }, null, -1, true);
         }
 
         return completionSource.Task;
     }
 
     static void TrySetResult<TResult>(
         this TaskCompletionSource<TResult> completionSource,
         IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod)
     {
         try
         {
             var result = endMethod(asyncResult);
             completionSource.TrySetResult(result);
         }
         catch (OperationCanceledException)
         {
             completionSource.TrySetCanceled();
         }
         catch (Exception genericException)
         {
             completionSource.TrySetException(genericException);
         }
     }
 }

The previous code fragment defines a helper method that behaves similar to TaskFactory.

Usage example:

Usage:
var client = new MyServiceClient();
 // EchoTaskAsync is an extension method
 var result = await client.EchoTaskAsync("zzzz");

And here is the service extension for MyServiceClient (Note that I use the service interface contract instead of the ClientBase<> as parameter since we need access to Begin/End methods):

Service Async Extensions
public static class ServiceExtensions
 {
     public static Task<string> EchoTaskAsync(
         this IMyService client, string text)
     {
         return MyTaskFactory.FromAsync<string>(
             client.BeginEcho(text, null, null),
             ar => client.EndEcho(ar));
     }
 }

Try it and let me know if it works for you..

We are recruiting..

javarg — Sun, 10 Apr 2011 21:26:53 GMT

We are looking for smart and young .NET software developers, passionate about technology for our Mexico City office. If your are interested send us an email with your CV to rrhh@lagash.com specifying you are interested in Mexico City positions.

Thanks!

Team Foundation Server: Server-side Validation & Interception

javarg — Tue, 29 Mar 2011 05:02:40 GMT

Some time ago I presented a simple way to version TFS Web Services in order to intercept and perform server side validations.

In this post I will introduce another way of doing so.

Check out the (poor documented) ITeamFoundationRequestFilter interface in MSDN. This interface is part of an extensibility method called TFS Filters.

* Many thanks to Grant Holliday for pointing me to this extension.

Using this interface as a regular TFS plug-in (meaning you deploy it in the plugins directory as you do with subscribers) you can inspect method executions, requests, etc.

It is very useful when you need to create an audit log, measure performance (recording execution time or calls), diagnose connection problems, etc. In fact, when you connect to TFS from a version of Visual Studio lower than 2010, an implementation of this filter (check the Microsoft.TeamFoundation.ApplicationTier.PlugIns.Core.UserAgentCheckingFilter) throws an exception indicating that you need a patch for doing so.

The latter is the functionality I am personally more interested in: validations.

The interface defines the following methods in order to handle a request life cycle (in chronological order):

BeginRequest: called when a new TFS request (ASP.NET) is about to be executed. At this phase, you do not know which operation is about to be executed (at least not directly).
RequestReady: called when security and message validations has already happened (only at Web Service level). At this phase, you do not know which operation is about to be executed (at least not directly).
EnterMethod: called when a logical TFS method is about to be called. At this phase, you now know which operation TFS is about to execute (and you even have its parameters).
LeaveMethod: called when a logical TFS method has already been executed.
EndRequest: called when ASP.NET request is about to end.

Sample debugging session (method information available when EnterMethod is executed):

Turns out that you can only abort the execution of the current request in the BeginRequest and RequestReady methods:

The only way of doing so, is throwing an exception that inherits from Microsoft.TeamFoundation.Framework.Server.RequestFilterException.
At this phase (BeginRequest or RequestReady), you do not know yet which Method is being called by the client (at least not directly).
Even if you throw exceptions from the EnterMethod method, you wouldn’t abort the current execution (there are some nice try-catch internal code preventing the error from aborting the execution). The exception will only be logged.

Note: As in my previous post, the next code sample is only meant to be an experiment in any case :).

By doing some ASP.NET HttRequest manipulation thought, you can implement a validation filter in the RequestReady or BeginRequest methods.

Get the current ASP.NET HttpContext.Request
Read the entire InputStream and then restore its original state (assuming it is not a forward only stream).
Deserialize the SOAP Envelope and reading the parameters from there.

So… as I already made it clear, consider other alternatives before using this as production code.

TFS Filter Sample
public class TeamFoundationRequestFilterSample : ITeamFoundationRequestFilter         
{         
    public void BeginRequest(TeamFoundationRequestContext requestContext)         
    {         
        // Can abort here         
        TfsPackageValidator.ValidatePackage();         
    }         
        
    public void RequestReady(TeamFoundationRequestContext requestContext)         
    {         
        // Can abort here         
    }         
        
    public void EndRequest(TeamFoundationRequestContext requestContext)         
    {         
    }         
        
    public void EnterMethod(TeamFoundationRequestContext requestContext)         
    {         
        // Cannot abort here         
    }         
        
    public void LeaveMethod(TeamFoundationRequestContext requestContext)         
    {         
        // Cannot abort here         
    }         
}

The above sample code validates inputs in the BeginRequest method (you can always move it to the RequestReady). The TfsPackageValidator class inspects the current ASP.NET request and deserializes the input parameters. If it finds an Update operation over a Work Item (by looking at the SOAP Message Body), it continues with the validation process. What we are looking for here, is the Package element with the update information about the work item.

And here is my TfsPackageValidator class:

TfsPackageValidator class
static class TfsPackageValidator         
{         
    public static void ValidatePackage()         
    {         
        var soapXml = ReadHttpContextInputStream();         
        
        var packageElement = ReadUpdatePackageFromSoapEnvelope(soapXml);         
        
        if (packageElement != null)         
            ValidatePackage(packageElement);         
    }         
        
    static void ValidatePackage(System.Xml.Linq.XElement package)         
    {         
        var updateWorkItemElement =         
            package.Descendants("UpdateWorkItem").FirstOrDefault();         
        
        if (updateWorkItemElement != null)         
        {         
            var priorityColumnElement =         
                updateWorkItemElement.Descendants("Column").Where(         
                    c => (string)c.Attribute("Column") == "Microsoft.VSTS.Common.Priority").FirstOrDefault();         
        
            if (priorityColumnElement != null)         
            {         
                int priority = 0;         
                var priorityText = priorityColumnElement.Descendants("Value").FirstOrDefault().Value;         
                if (!string.IsNullOrEmpty(priorityText) && int.TryParse(priorityText, out priority))         
                {         
                    if (priority > 2)         
                        throw new TeamFoundationRequestFilterException("Priorities grater than 2 are not allowed.");         
                }         
            }         
        }         
    }         
        
    static XElement ReadUpdatePackageFromSoapEnvelope(string soapXml)         
    {         
        var soapDocument = XDocument.Parse(soapXml);         
        
        var updateName =         
            XName.Get(         
                "Update",         
                "http://schemas.microsoft.com/TeamFoundation/2005/06/WorkItemTracking/ClientServices/03");         
        
        var updateElement =         
            soapDocument.Descendants(updateName).FirstOrDefault();         
        
        return updateElement;         
    }         
        
    static string ReadHttpContextInputStream()         
    {         
        var httpContext = System.Web.HttpContext.Current;         
        
        string soapXml = null;         
        using (var memoryStream = new MemoryStream())         
        {         
            byte[] buffer = new byte[1024 * 4];         
            int count = 0;         
            while ((count = httpContext.Request.InputStream.Read(buffer, 0, buffer.Length)) > 0)         
                memoryStream.Write(buffer, 0, count);         
            memoryStream.Seek(0, SeekOrigin.Begin);         
            httpContext.Request.InputStream.Seek(0, SeekOrigin.Begin);         
        
            soapXml = Encoding.UTF8.GetString(memoryStream.GetBuffer());         
        }         
        
        return soapXml;         
    }         
}

Try running this code when saving a Work Item with a priority field (by editing a single Work Item. If you edit the work item in a query view, the message passed to the server would be slightly different). You should see something similar to the following message in the client application:

The exception message is displayed in the dialog box (as a Technical information for administrator).

Download the sample code.

Webcast MSDN: Migración y construcción de aplicaciones para Windows Azure con VM Role y el modo de administración

javarg — Fri, 25 Mar 2011 03:34:08 GMT

I will participating in a new Screencast tomorrow about new Azure features requested by the community. Admin mode and VM Role.

Click here to join.

Asynchrony in C# 5: Dataflow Async Logger Sample

javarg — Tue, 15 Mar 2011 06:20:52 GMT

Check out this (very simple) code examples for TPL Dataflow.

Suppose you are developing an Async Logger to register application events to different sinks or log writers.

The logger architecture would be as follow:

Note how blocks can be composed to achieved desired behavior. The BufferBlock<T> is the pool of log entries to be process whereas linked ActionBlock<TInput> represent the log writers or sinks.

The previous composition would allows only one ActionBlock to consume entries at a time.

Implementation code would be something similar to (add reference to System.Threading.Tasks.Dataflow.dll in %User Documents%\Microsoft Visual Studio Async CTP\Documentation):

TPL Dataflow Logger
var bufferBlock = new BufferBlock<Tuple<LogLevel, string>>();
 
 ActionBlock<Tuple<LogLevel, string>> infoLogger = 
     new ActionBlock<Tuple<LogLevel, string>>(
         e => Console.WriteLine("Info: {0}", e.Item2));
 
 ActionBlock<Tuple<LogLevel, string>> errorLogger = 
     new ActionBlock<Tuple<LogLevel, string>>(
         e => Console.WriteLine("Error: {0}", e.Item2));
 
 bufferBlock.LinkTo(infoLogger, e => (e.Item1 & LogLevel.Info) != LogLevel.None);
 bufferBlock.LinkTo(errorLogger, e => (e.Item1 & LogLevel.Error) != LogLevel.None);
 
 bufferBlock.Post(new Tuple<LogLevel, string>(LogLevel.Info, "info message"));
 bufferBlock.Post(new Tuple<LogLevel, string>(LogLevel.Error, "error message"));

Note the filter applied to each link (in this case, the Logging Level selects the writer used). We can specify message filters using Predicate functions on each link.

Now, the previous sample is useless for a Logger since Logging Level is not exclusive (thus, several writers could be used to process a single message).

Let´s use a Broadcast<T> buffer instead of a BufferBlock<T>.

Broadcast Logger
var bufferBlock = new BroadcastBlock<Tuple<LogLevel, string>>(
     e => new Tuple<LogLevel, string>(e.Item1, e.Item2));
 
 ActionBlock<Tuple<LogLevel, string>> infoLogger = 
     new ActionBlock<Tuple<LogLevel, string>>(
         e => Console.WriteLine("Info: {0}", e.Item2));
 
 ActionBlock<Tuple<LogLevel, string>> errorLogger = 
     new ActionBlock<Tuple<LogLevel, string>>(
         e => Console.WriteLine("Error: {0}", e.Item2));
 
 ActionBlock<Tuple<LogLevel, string>> allLogger =
     new ActionBlock<Tuple<LogLevel, string>>(
     e => Console.WriteLine("All: {0}", e.Item2));
 
 bufferBlock.LinkTo(infoLogger, e => (e.Item1 & LogLevel.Info) != LogLevel.None);
 bufferBlock.LinkTo(errorLogger, e => (e.Item1 & LogLevel.Error) != LogLevel.None);
 bufferBlock.LinkTo(allLogger, e => (e.Item1 & LogLevel.All) != LogLevel.None);
 
 bufferBlock.Post(new Tuple<LogLevel, string>(LogLevel.Info, "info message"));
 bufferBlock.Post(new Tuple<LogLevel, string>(LogLevel.Error, "error message"));

As this block copies the message to all its outputs, we need to define the copy function in the block constructor. In this case we create a new Tuple, but you can always use the Identity function if passing the same reference to every output.

Try both scenarios and compare the results.

Asynchrony in C# 5 (Part II)

javarg — Mon, 14 Mar 2011 22:15:28 GMT

This article is a continuation of the series of asynchronous features included in the new Async CTP preview for next versions of C# and VB. Check out Part I for more information.

So, let’s continue with TPL Dataflow:

Asynchronous functions
TPL Dataflow
Task based asynchronous Pattern

Part II: TPL Dataflow

Definition (by quote of Async CTP doc): “TPL Dataflow (TDF) is a new .NET library for building concurrent applications. It promotes actor/agent-oriented designs through primitives for in-process message passing, dataflow, and pipelining. TDF builds upon the APIs and scheduling infrastructure provided by the Task Parallel Library (TPL) in .NET 4, and integrates with the language support for asynchrony provided by C#, Visual Basic, and F#.”

This means: data manipulation processed asynchronously.

“TPL Dataflow is focused on providing building blocks for message passing and parallelizing CPU- and I/O-intensive applications”.

Data manipulation is another hot area when designing asynchronous and parallel applications: how do you sync data access in a parallel environment? how do you avoid concurrency issues? how do you notify when data is available? how do you control how much data is waiting to be consumed? etc.

Dataflow Blocks

TDF provides data and action processing blocks. Imagine having preconfigured data processing pipelines to choose from, depending on the type of behavior you want. The most basic block is the BufferBlock<T>, which provides an storage for some kind of data (instances of <T>).

So, let’s review data processing blocks available. Blocks a categorized into three groups:

Buffering Blocks
Executor Blocks
Joining Blocks

Think of them as electronic circuitry components :)..

1. BufferBlock<T>: it is a FIFO (First in First Out) queue. You can Post data to it and then Receive it synchronously or asynchronously. It synchronizes data consumption for only one receiver at a time (you can have many receivers but only one will actually process it).

2. BroadcastBlock<T>: same FIFO queue for messages (instances of <T>) but link the receiving event to all consumers (it makes the data available for consumption to N number of consumers). The developer can provide a function to make a copy of the data if necessary.

3. WriteOnceBlock<T>: it stores only one value and once it’s been set, it can never be replaced or overwritten again (immutable after being set). As with BroadcastBlock<T>, all consumers can obtain a copy of the value.

4. ActionBlock<TInput>: this executor block allows us to define an operation to be executed when posting data to the queue. Thus, we must pass in a delegate/lambda when creating the block. Posting data will result in an execution of the delegate for each data in the queue.

You could also specify how many parallel executions to allow (degree of parallelism).

5. TransformBlock<TInput, TOutput>: this is an executor block designed to transform each input, that is way it defines an output parameter. It ensures messages are processed and delivered in order.

6. TransformManyBlock<TInput, TOutput>: similar to TransformBlock but produces one or more outputs from each input.

7. BatchBlock<T>: combines N single items into one batch item (it buffers and batches inputs).

8. JoinBlock<T1, T2, …>: it generates tuples from all inputs (it aggregates inputs). Inputs could be of any type you want (T1, T2, etc.).

9. BatchJoinBlock<T1, T2, …>: aggregates tuples of collections. It generates collections for each type of input and then creates a tuple to contain each collection (Tuple<IList<T1>, IList<T2>>).

Next time I will show some examples of usage for each TDF block.

* Images taken from Microsoft’s Async CTP documentation.