WF4 Activities and Callbacks / Event Handlers

by community-syndication | Sep 29, 2010 | BizTalk Community Blogs via Syndication

Recently David K contacted me through my blog and shared with me a solution that he came up with for a particular problem that he was able to solve using IWorkflowInstanceExtension and said it would be great if I could do an endpoint.tv episode about it.  David already solved his problem but he wanted to spare you the pain in case you ever have to do this.

Download WF4 Activity Callbacks and Events Example from MSDN Code Gallery

The Problem

Let’s imagine that you have a class library that exposes a type called Gizmo.  This Gizmo type exposes an event that is fired from time to time for some reason (maybe it detects some input from a hardware device) and you want to create an activity that will wait for the Gizmo.Fire event and return the level that was fired.

public class Gizmo

{

    public event EventHandler<GizmoEventArgs> Fire;



    public void FireGizmo(int level)

    {

        if (Fire != null)

        {

            Fire(this, new GizmoEventArgs {Level = level});

        }

    }

}

Activities cannot just sit around waiting for an event and blocking the workflow thread so we need a way to add an event handler that can handle the event and resume the workflow once it is fired. Also we need to be sure that this works correctly even if the workflow host has a persistence enabled. Because there is no way for an activity to re-establish connections with event handlers when being loaded from persistence we have to avoid being persisted while we have a connection to the Gizmo.Fire event.

The Solution

The solution is to pair the Activity with an Extension.  It works like this.

1. Create an activity called WaitForGizmo and an extension called WaitForGizmoExtension which implements IWorkflowInstanceExtension
2. When the Activity is executed it will enter a no-persist zone and let the extension know when it needs to handle the event and set a bookmark
3. The WaitForGizmoExtension will handle the event and resume the bookmark
4. When the bookmark is resumed the activity will obtain the out argument values and exit the no-persist scope

This is the right way for dealing with CLR events and callbacks.

The WaitForGizmo activity

public sealed class WaitForGizmo : NativeActivity<int>

{

    internal const string BookmarkName = "WaitingForGizmoToBeFired";

    private readonly Variable<NoPersistHandle> _noPersistHandle = new Variable<NoPersistHandle>();

    private BookmarkCallback _gizmoBookmarkCallback;



    public InArgument<Gizmo> TheGizmo { get; set; }



    public BookmarkCallback GizmoBookmarkCallback

    {

        get

        {

            return _gizmoBookmarkCallback ??

                    (_gizmoBookmarkCallback = new BookmarkCallback(OnGizmoCallback));

        }

    }



    protected override bool CanInduceIdle

    {

        get { return true; }

    }



    protected override void CacheMetadata(NativeActivityMetadata metadata)

    {

        // Tell the runtime that we need this extension

        metadata.RequireExtension(typeof (WaitForGizmoExtension));



        // Provide a Func<T> to create the extension if it does not already exist

        metadata.AddDefaultExtensionProvider(() => new WaitForGizmoExtension());



        metadata.AddArgument(new RuntimeArgument("TheGizmo", typeof (Gizmo), ArgumentDirection.In, true));

        metadata.AddArgument(new RuntimeArgument("Result", typeof (int), ArgumentDirection.Out, false));

        metadata.AddImplementationVariable(_noPersistHandle);

    }



    protected override void Execute(NativeActivityContext context)

    {

        // Enter a no persist zone to pin this activity to memory since we are setting up a delegate to receive a callback

        var handle = _noPersistHandle.Get(context);

        handle.Enter(context);



        // Get (which may create) the extension

        var gizmoExtension = context.GetExtension<WaitForGizmoExtension>();



        // Add the callback

        gizmoExtension.AddGizmoCallback(TheGizmo.Get(context));



        // Set a bookmark - the extension will resume when the Gizmo is fired

        context.CreateBookmark(BookmarkName, GizmoBookmarkCallback);

    }



    internal void OnGizmoCallback(NativeActivityContext context, Bookmark bookmark, Object value)

    {

        // Store the result

        Result.Set(context, (int) value);



        // Exit the no persist zone 

        var handle = _noPersistHandle.Get(context);

        handle.Exit(context);

    }

}

The WaitForGizmoExtension

internal class WaitForGizmoExtension : IWorkflowInstanceExtension

{

    private static bool _addedCallback;

    private WorkflowInstanceProxy _instance;



    #region IWorkflowInstanceExtension Members



    public IEnumerable<object> GetAdditionalExtensions()

    {

        return null;

    }



    public void SetInstance(WorkflowInstanceProxy instance)

    {

        _instance = instance;

    }



    #endregion



    internal void AddGizmoCallback(Gizmo gizmo)

    {

        if (!_addedCallback)

        {

            _addedCallback = true;

            gizmo.Fire += OnGizmoFired;

        }

    }



    internal void OnGizmoFired(object sender, GizmoEventArgs args)

    {

        // Gizmo was fired, resume the bookmark

        _instance.BeginResumeBookmark(

            new Bookmark(WaitForGizmo.BookmarkName),

            args.Level,

            (asr) => _instance.EndResumeBookmark(asr),

            null);

    }

}

Handling Timeouts

What if Gizmo does not fire? You might want to have a solution where if Gizmo doesn’t fire within some timeout period you do something else. The best way to deal with this is at the workflow level by using a Pick activity with a branch that contains a delay. This ensures that either a Gizmo.Fire event is detected or the Timeout occurs

Book review: Silverlight 4 in Action

by community-syndication | Sep 29, 2010 | BizTalk Community Blogs via Syndication

Some weeks ago I received a review copy of Silverlight 4 in Action by Pete Brown. Reviewing this book took some time as it weighs in at a hefty 798 pages, who ever said that Silverlight was a small products? That is a lot of material but then the book doesn't assume any prior knowledge of Silverlight at all.

The book is divided into 25 chapters in 3 different sections.

The first part, consisting of 10 chapters, is titled "Introducing Silverlight". As the name suggests this covers the basics of Silverlight development. This section is mostly targeted at developers new to Silverlight and covers subjects like what XAML is, how the Silverlight plug-in works with the browser, basic layout and the Silverlight controls and how they work with things like templates.

The second part is titled "Structuring your application". This section is divided into 7 chapters and build on top of the first part. In this section there are chapters about data binding, input validation, communicating and even about subjects like MVVM and WCF RIA services. Some of these topics, like for example MVVM, are quite large to begin with and the definitive word hasn't been said about it. In these cases the book is a nice point to get started but no more than that and getting additional information on the Internet is pretty much a requirement. In most cases, like validation. Pete has a pretty solid coverage of the material the book will help you understand what you need to know.

The third part is titled "Completing the experience" and consist of a final 8 chapters. This section covers subjects like printing, working with media like smooth streaming or using the webcam and microphone.
There are also chapters on animations, using resources and creating custom controls.

So who is this book for?
With a book this big covering that many topics the book is really targeted at a wide range of developers. It does assume the reader is familiar with C# and the .NET framework but assumes no familiarity with Silverlight at all. So if you are an experienced .NET developer wanting to get into Silverlight this is a good book to start with using part 1. You you are already a Silverlight developer moving from Silverlight 3 to Silverlight 4 this book will also be quite helpful. You will find a lot of material you are already familiar with but also a lot of new material like web cam support and WCF RIA services or extended validation options. In that case this book would be a useful reference to keep handy and read specific chapters from par 2 or 3 when needed.

All in all I would recommend getting this book if you are serious about Silverlight 4 development!

Enjoy!

BizTalk Patterns part 1 – Asynchronous Aggregation

by community-syndication | Sep 29, 2010 | BizTalk Community Blogs via Syndication

Developing a BizTalk Server solution can be challenging, and especially complex for those who are unfamiliar with it. Developing with BizTalk Server, like any software development effort is like playing chess. There are some great opening moves in chess, and there are some great patterns out there to start a solution. Besides being an outstanding communications tool, design patterns help make the design process faster. This allows solution providers to take the time to concentrate on the business implementation. More importantly, patterns help formalize the design to make it reusable. Reusability not only applies to the components themselves, but also to the stages the design must go through to morph itself into the final solution. The ability to apply a patterned repeatable solution is worth the little time spent learning formal patterns, or to even formalize your own. This entry looks at how architectural design considerations associated to BizTalk Server regarding messaging and orchestration can be applied using patterns, across all industries. The aim is to provide a technical deep-dive using BizTalk Server anchored examples to demonstrate best practices and patterns regarding parallel processing, and correlation.

The blog entry http://blogs.msdn.com/b/quocbui/archive/2009/10/16/biztalk-patterns-the-parallel-shape.aspx examines a classic example of parallel execution. It is consists of de-batching a large message file into smaller files, apply child business process executions on each of the smaller files, and then aggregating all the results into a single large result. Each subset (small file) represents an independent unit of work that does not rely or relate to other subsets, except that it belongs to the same batch (large message). Eventually each child process (the independent unit of work) will return a result message that will be collected with other results, into a collated response message to be leveraged for further processing.

This pattern is a relatively common requirement by clients and systems that interact with BizTalk Server, where a batch is sent in and they require a batch response with the success/failure result for each message. With this pattern one can still leverage the multithreaded nature of BizTalk’s batch disassembly while still conforming to requirement of the client.

Let’s closely examine how this example works. First, it uses several capabilities of BizTalk that are natively provided – some that are well documented, and some that are not. A relatively under-utilized feature – that BizTalk Server natively provides, is the ability to de-batch a message (file splitting) from its Receive pipeline. BizTalk Server can take a large message with any number of child records (which are not dependent with one another, except for the fact that they all belong to the same batch), and split out the child records to become independent messages for a child business process to act on. This child business process can be anything – such as a BizTalk Orchestration function, or a Windows Workflow.

To learn how to split a large file (also known as as de-batching) into smaller files, please refer to the BizTalk Server 2006 samples – Split File Pipeline example. Even though the sample is based on BizTalk Server 2006 (R1) – it remains relevant for BizTalk Server 2006 R2, BizTalk Server 2009, and BizTalk Server 2010.
Note: There are several examples on how to de-batch messages, such as de-batching from SQL Server, as communicated on Rahul Garg’s blog on de-batching.

After the large file has been split into smaller child record messages, child business processes can simultaneously work on each of these smaller files, which will eventually create child result messages. These child result messages can then be picked up by BizTalk Server and published to the BizTalk MessageBox database.

To aggregate the results back to the same batch, correlation has to be used. BizTalk Orchestration provides the ability to correlate. Aggregation with Orchestration is relatively easy to develop. Using Orchestration, however, may require more hardware resources (memory, CPU) than necessary. One Orchestration instantiation will be required per batch (so if there’s 1000 large batch messages, then there will be 1000 Orchestration instances). Orchestrations linger until the last result message has arrived (or it can time out from a planned exception handling). There is an alternative way to aggregate, without Orchestration, but correlation is still necessary and required to collate all the results into the same batch. The trick is to correlate the result messages without Orchestration.

Let’s examine how correlation without Orchestration can be achieved.

Paolo Salvatori, in his first blog entry http://blogs.msdn.com/paolos/archive/2008/07/21/msdn-blogs.aspx describes how to correlate without Orchestration, by using a two-way receive port. This is important to note, because the two-way receive port provides key information that can be leveraged, by promoting them to the context property bag.

Correlation without Orchestration is as easy as just promoting the right information to the context property bag. Of course, this information needs to be persisted, maintained, and returned with the result messages. However, this method only works with a two-way receive port. What about from a one-way receive port, such as from a file directory or MSMQ?

That is still possible because the de-batching (file splitting) mechanism of BizTalk Server provides a different set of compound key properties that can be used.

The final step is to aggregate all the result messages and ensure that they’re correctly collated into the same batch that their original source messages from from. The UID that was used for correlation, is the parent identifier that can be used to group these result messages into. An external database table can be used to temporarily store the incoming messages, and a single SQL Stored Procedure can be used to extrapolate these messages into a single output file.

• A result message is received by a FILE Receive Port
• This result message is stored in a SQL Server table. This is achieved by being routed to a SQL Send Port where the original message is wrapped into a sort of envelope by a map which uses a custom XSLT. The outbound message is an Updategram which calls a stored procedure to insert the message into the table.
• A SQL receive port calls a stored procedure to retrieve the records of a certain type from the custom table. This operation generates a single document.
• This document is routed to a File Send Port where the message is eventually transformed into another format.

This method of using a SQL aggregator was communicated in http://geekswithblogs.net/asmith/archive/2005/06/06/42281.aspx

Note that the XSLT can be eventually replaced by a custom pipeline component or directly by an envelope (in this case the send pipeline needs to contain the Xml Assembler component).

Acknowledgements to: Thiago Almeida (Datacom), Werner Van Huffel (Microsoft), Ji Young Lee (Microsoft), Paolo Salvatori (Microsoft)

New MS.COM SQL Azure website and free trial

by community-syndication | Sep 29, 2010 | BizTalk Community Blogs via Syndication

http://www.microsoft.com/en-us/sqlazure/default.aspx

New Blog Home & a New BizTalk Version

by community-syndication | Sep 28, 2010 | BizTalk Community Blogs via Syndication

Blog Update Yesterday I found out about the big change Microsoft was making to abandon the Live Spaces blog platform. I had been using this platform for the past three years so I am sorry to see it go. It was definitely not perfect but I found it to have better search engine rankings and […]

ASP.NET Security Update Now Available

by community-syndication | Sep 28, 2010 | BizTalk Community Blogs via Syndication

Free e-book offer from Microsoft Press – Introducing Windows Server 2008 R2

by community-syndication | Sep 28, 2010 | BizTalk Community Blogs via Syndication

Microsoft is offering a free e-book to partners. Learn about the features of Windows Server 2008 R2 in the areas of virtualization, management, the web application platform, scalability and reliability, and interoperability with Windows 7. Sign in to download Introducing Windows Server 2008 R2, written by industry experts Charlie Russel and Craig Zacker along with the Windows Server team at Microsoft.

Sign in to Microsoft Partner site to download the free e-book.

Modernizing BizTalk Server BAM with PowerPivot

by community-syndication | Sep 28, 2010 | BizTalk Community Blogs via Syndication

Business Activity Monitoring (BAM) is one of the most attractive features of the BizTalk Server product family. Since its first release in 2004, BAM have been positioned as a mechanism to enable real time visibility across business processes implemented…(read more)

LOTS and LOTS of BizTalk Server 2010 Resources

by community-syndication | Sep 28, 2010 | BizTalk Community Blogs via Syndication

This post is a follow-up to the RTM last week of BizTalk Server 2010. The BizTalk User Experience team has been REALLY busy putting together a ton of great resources. These are all live now, enjoy!

Learning:

• BizTalk Server 2010 Training Kit
• Video tutorials
• Working with BizTalk AppFabric Connect

Documentation:

• BizTalk Server 2010 Help
• BizTalk RFID Server 2010 and BizTalk RFID Mobile 2010 Help
• BizTalk Server 2010 ESB Toolkit Documentation
• BizTalk Server Best Practices Analyzer
• UDDI Help
• BizTalk Server 2010 Management Pack Documentation
• Windows Communication Foundation (WCF) Line of Business (LOB) Adapter SDK 2010 Documentation
• BizTalk Adapter Pack 2010 Help
• BizTalk Adapters 2010 for Enterprise Applications
• BizTalk Accelerator for RosettaNet
• BizTalk 2010 Accelerator for HL7 (BTAHL7) Documentation
• BizTalk 2010 Accelerator for A4SWIFT
• BizTalk 2010 FileAct and InterAct Adapters
• Host Integration Server 2010 Help

Posters:

• BizTalk Server 2010 Scale-out Configurations Poster
• BizTalk Server 2010 Runtime Architecture Poster
• BizTalk Server 2010 Capabilities Poster
• BizTalk Server 2010 Database Infrastructure Poster
• BizTalk Server 2010 BAM Poster
• BizTalk Server 2010 ESB Toolkit Architecture Poster