The Problem Solver : NetFx3

Workflow 4 and Visual Basic expressions

Maurice — Mon, 26 Oct 2009 15:20:46 GMT

Note: This blog post is written using the .NET framework 4.0 Beta 2

When using Windows Workflow Foundation 4 you often need to enter expression in some activity property. The new thing is these expressions are all in the Visual Basic dialect regardless of what language you project is in. So when developing a project in C# the expressions are sill in Visual Basic.

Weird right?

Well not really when you think about it!

After all power business users are expected to be able to modify workflows. And guess what their favorite tools are. That would be Microsoft Excel and Word. And what do they use to create macros? Right Visual Basic for Applications is their language of choice.

So if they use VBA letting them enter VB into expression dialogs is a far more natural fit than having them use C#.

A case for the Delay activity

So lets take a look at the delay activity. This activity takes 1 input property Duration of type Time Span. So I guess that means our VBA power users are going to have to enter something like if they want to wait 5 seconds:

Now for some reason I suspect that is not the first thing they are going to type. In fact they are more likely to time something like “0:0:05” instead. Not very VB like right?

Well it turns out workflow is smart enough to realize it can convert the string literal to a Time Span and use this. So when our power users does the following it just works

Nice, I like this!

Enjoy WF4!

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

Nederlandse CodeCamp 2009

Maurice — Mon, 19 Oct 2009 10:26:00 GMT

Op 21 november 2009 organiseren de SDN, Stichting dotNed en VBcentral samen het derde Nederlandse Code Camp. Dit is een dag lang met code, code sharing, freaking en gezellig samenzijn. Een evenement door ontwikkelaars, voor ontwikkelaars. De regie ligt voor een belangrijk deel bij de deelnemers! Het aantal plaatsen voor deelnemers is wel beperkt tot maximaal 150. Wacht dus niet te lang met beslissen want voor je het weet is er geen plaats meer. Vergeet bij je aanmelding niet op te geven welke onderwerpen je interesse hebben. Bovendien nodigen we iedereen graag uit om zelf een sessie in te vullen.

Op de website, www.codecamp.nl, vind je meer informatie en kan je je aanmelden.

Sending your own objects to a WF4 workflow

Maurice — Thu, 20 Aug 2009 13:11:00 GMT

In the previous two blog posts (here and here) I showed how to create and expose a Windows Workflow Foundation 4 workflow via WCF and have both a workflow and a regular C# client work with it. But the parameter and return value where real simple with just a string each. So how about passing some more complex data.

To show how to do so I will replace the singe string with a person object. Admittedly not the most complex person with only an id, first and last name and their birth date but enough to demonstrate the principal.

The main of the service, which uses a WorkflowServiceHost, stays exactly the same so see the first blog post for that part. The CreateWorkflow() function will change now reflecting the fact that the service will no longer expect a string but a person object.

private static WorkflowElement CreateWorkflow()

    var result = new Sequence();

    var input = new Variable<Person>();

    result.Variables.Add(input);

    XNamespace ns = "http://tempuri.org";

    var handle = new Variable<CorrelationHandle>();

    result.Variables.Add(handle);

    var receive = new Receive()

        OperationName = "Operation1",

        ServiceContractName = ns + "MyService",

        Value = new OutArgument<Person>(input),

        AdditionalCorrelations = {

           {"ChannelBasedCorrelation", new InArgument<CorrelationHandle>(handle)}

},

        CanCreateInstance = true

};

    result.Activities.Add(receive);

    var write = new WriteLine()

        Text = new InArgument<string>(env => string.Format("\tThe workflow was called with '{0}'.", input.Get(env)))

};

    result.Activities.Add(write);

    var reply = new SendReply()

        Request = receive,

        Value = new InArgument<string>("The result")

};

    result.Activities.Add(reply);

    return result;

Not a big change really as we only have to change the input variable from Variable<string> to Variable<Person> and do the same with the Value property of the Receive activity which goes from new OutArgument<string>(input) to new OutArgument<Person>(input).

That leaves the Person class and this is just straightforward WCF work by turning the basic class into a data contract.

[DataContract(Namespace = "urn:WF4Sample:person")]

public class Person

    [DataMember]

    public int Id { get; set; }

    [DataMember]

    public string FirstName { get; set; }

    [DataMember]

    public string LastName { get; set; }

    [DataMember]

    public DateTime BirthDate { get; set; }

    public override string ToString()

        return string.Format("{0} {1} was born on {2} (ID: {3})", FirstName, LastName, BirthDate, Id);

Again no big deal

So with the service done we need to make the same changes to the two client applications. First the workflow client using the Send activity.

The Person class is exactly the same as on the server so just copy the code as is. Again the main in the workflow client doesn’t change, see the first blog post for that part. The part that does change a little is the CreateWorkflow() function so it creates and sends a Person instead of a string. The code goes as follows:

private static WorkflowElement CreateWorkflow()

    var result = new Sequence();

    XNamespace ns = "http://tempuri.org";

    var endpoint = new Endpoint()

        Uri = new Uri("http://localhost:8090/Sequence1/Operation1"),

        Binding = new BasicHttpBinding()

};

    var response = new Variable<string>();

    result.Variables.Add(response);

    var handle = new Variable<CorrelationHandle>();

    result.Variables.Add(handle);

    var person = new Person()

        Id = 7,

        FirstName = "Maurice",

        LastName = "de Beijer",

        BirthDate = new DateTime(1962, 8, 24)

};

    var request = new Send()

        OperationName = "Operation1",

        Endpoint = endpoint,

        AdditionalCorrelations =

           {"ChannelBasedCorrelation", new InArgument<CorrelationHandle>(handle)}

},

        ServiceContractName = ns + "MyService",

        Value = new InArgument<Person>(person)

};

    result.Activities.Add(request);

    var reply = new ReceiveReply()

        Request = request,

        Value = new OutArgument<string>(response)

};

    result.Activities.Add(reply);

    var write = new WriteLine()

        Text = new InArgument<string>(response)

};

    result.Activities.Add(write);

    return result;

Again a very minor change.

So how about the C# console client from the second blog post?

The service contract changes a little and is now:

[ServiceContract]

interface MyService

    [OperationContract]

    Operation1Response Operation1(Person request);

The person class is very different from the service though and looks like this:

[MessageContract(WrapperNamespace = "urn:WF4Sample:person")]

internal class Person

    [MessageBodyMember(Namespace = "urn:WF4Sample:person")]

    public int Id { get; set; }

    [MessageBodyMember(Namespace = "urn:WF4Sample:person")]

    public string FirstName { get; set; }

    [MessageBodyMember(Namespace = "urn:WF4Sample:person")]

    public string LastName { get; set; }

    [MessageBodyMember(Namespace = "urn:WF4Sample:person")]

    public DateTime BirthDate { get; set; }

But besides the difference from using a message contract as opposed to a data contract this isn’t a big deal.

The main program changes a bit but not a whole lot. Again the only changes are due to the fact we are passing in a Person instead of a string.

static void Main(string[] args)

    var binding = new BasicHttpBinding();

    var endpoint = new EndpointAddress("http://localhost:8090/Sequence1/Operation1");

    var factory = new ChannelFactory<MyService>(binding, endpoint);

    var proxy = factory.CreateChannel();

    var request = new Person()

        Id = 23,

        FirstName = "Joe",

        LastName = "Regular",

        BirthDate = new DateTime(1975, 7, 1)

};

    var result = proxy.Operation1(request);

    Console.WriteLine(result.Value);

    Console.WriteLine("Regular client is done.");

    Console.ReadLine();

All together not bad.

But so far we have only used a very simple workflow with a single message send to it. Suppose you want to send multiple messages to the same workflow? Well in that case we need to use message correlation as we will see next time.

Enjoy!

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

Using Windows Workflow Foundation 4 Receive from an non WF client

Maurice — Wed, 19 Aug 2009 10:09:23 GMT

In a previous blog post I described how to use the WorkflowServiceHost and host a workflow with a Receive activity that waits for WCF messages. I also added a WF4 client that called the service and received a response. However a lot of clients out there are not going to be workflows but “regular” code that calls into out workflow. So what does it take to have a simple console application talk to our WF4 service?

The first thing we need is an service contract describing the operation we can call. In our workflow the operation is named “Operation1” and our service contact name was “MyService” with the default namespace of “http://tempuri.org”. So our service contract looks like this:

[ServiceContract]

interface MyService

    [OperationContract]

    Operation1Response Operation1(Operation1Request request);

Next up are the request and response objects. In this case I am using just two strings so they are pretty simple as well.

[MessageContract(IsWrapped = false)]

public class Operation1Request

    [MessageBodyMember(

        Namespace = "http://schemas.microsoft.com/2003/10/Serialization/",

        Name = "string")]

    public string Value { get; set; }

[MessageContract(IsWrapped = false)]

public class Operation1Response

    [MessageBodyMember(

        Namespace = "http://schemas.microsoft.com/2003/10/Serialization/",

        Name = "string")]

    public string Value { get; set; }

The interesting to note here is that I have to use a MessageContact instead of a DataContract and I have to make sure the data isn’t wrapped in an extra element. Also interesting is the fact that the data is send across using the name “string”, not the easiest C# identifier to work with so I called them “Value” instead.

Using these WCF definitions creating a simple console app that calls the workflow is a breeze.

static void Main(string[] args)

    var binding = new BasicHttpBinding();

    var endpoint = new EndpointAddress("http://localhost:8090/Sequence1/Operation1");

    var factory = new ChannelFactory<MyService>(binding, endpoint);

    var proxy = factory.CreateChannel();

    var request = new Operation1Request()

        Value = "Test from a console."

};

    var result = proxy.Operation1(request);

    Console.WriteLine(result.Value);

    Console.WriteLine("Regular client is done.");

    Console.ReadLine();

Enjoy!

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

What does Windows Workflow Foundation 4 mean for existing workflow developers?

Maurice — Fri, 03 Jul 2009 20:12:54 GMT

The question of what Windows Workflow Foundation version 4 means for developers currently developing using WF recently came up. As I mentioned before WF 4 is a complete rewrite and doesn’t use any of the existing WF 3 classes. The design of WF 4 is even quite different from the design of WF 3.

So are WF 3 developers completely left in the dark and have to start from scratch? And what about their existing applications, will they still run on .NET 4 or are they stuck in .NET 3.5 until the end of times?

Fist of all let me address why I believe Microsoft could make such a radical change. Keep i mind this is just my personal opinion and I might be completely wrong .

WF 3 was never widely adopted so I believe the team felt they could do this and not create too much of a problem. Personally I don't think the low adoption of WF 3 had anything to do with the technology. Sure it has its problems but most people never got to the point that they ran into real technical issues. Instead most people looked, didn't understand and quit. So IMHO the main problem was far more a question if evangelism that technology.

So what is the big issue with a migration from WF 3 to WF 4?

One big issue with WF 4 is that Microsoft decided not to release a state machine implementation. In WF 3 there was a choice between state machine and sequential workflows. In WF 4 there is a choice between sequential and flow chart. And in WF 3 a state machine turned out to be far more flexible and useful and quite a few cases are not really covered by the WF 4 model. There are a few workarounds to do something like a state machine in WF 4 but they are not pretty. That said, a number of state machine workflows could very well be done using a flow chart.

As far as backward compatibility the story is a bit more complicated. WF 4 ships with an interop activity you can use to host custom WF 3 activities in a WF 4 workflow. How good or bad this is? I really don't know yet but given how different the two designs are I fear it is very limited.

But WF 3 developers need not worry about their existing projects!

There is however a second side to the compatibility story. .NET 4 will ship both with the WF 3 and the WF 4 runtimes. The WF 3 runtime will not be prominent but it will still be there so all existing WF 3 applications will continue to run as is. And because it is part of the current .NET framework I suspect this is a legal requirement (but then I am no lawyer so could be wrong here). So there is no reason for existing workflow developers to panic just yet .

So existing workflow developers should start learning WF 4 for future projects but can continue to keep using their existing WF 3 solutions for the foreseeable future.

Enjoy!

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

Want to download all MIX sessions?

Maurice — Tue, 31 Mar 2009 06:52:40 GMT

Then you should check Mike Swanson’s blog post here. He has two batch files, the first downloads all MIX session recordings with in the format you like, the second renames them so it is easier to make sense of all the media file names.

If you just want a list of all sessions with download links this page might be the thing for you.

So much better than downloading them by hand. Not as good as going to the MIX itself but if you, like me, couldn’t go it is still a nice way to see all the content.

Enjoy!

Software Development Event march 30th

Maurice — Mon, 23 Mar 2009 15:40:29 GMT

Just one week to go to the next Software Development Event. The schedule with all the sessions is looking good. But this time there is even more!

We will have a Microsoft Surface machine somewhere in the common area for people to try our. And if you have never played, oops tested, with a Surface machine before this is a truly exiting machine!

Just goes to show, the SDN will go to extraordinary efforts to please all attendees

You can see the full schedule here. And don’t forget, we are not in Ede this time but in a great new location in Driebergen.

Hope to see everyone there next week Monday.

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

And now on Twitter at http://twitter.com/mauricedb.

Using Windows Workflow Foundation with Windows Communication Foundation

Maurice — Sat, 21 Mar 2009 06:05:00 GMT

Attached are the PowerPoint presentation and samples from my WF with WCF presentation in Timisoara, Romania. Thanks to Ineta for providing the funding for this.

Download the PowerPoint and samples

Unleash the power of State Machine Worklfows

Maurice — Sat, 21 Mar 2009 05:46:00 GMT

Attached are the PowerPoint presentation and samples from my state machine workflow presentation in Timisoara, Romania. Thanks to Ineta for providing the funding for this.

Download the PowerPoint and samples

Samples and PowerPoint from my WCF talk

Maurice — Wed, 11 Mar 2009 04:25:00 GMT

Attached is are the samples and slides I used for my intro into WCF talk yesterday at the VB Central meeting in the Netherlands.

Download samples

Enjoy!

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

Now also on twitter at http://twitter.com/mauricedb

Using a TransactionScopeActivity with a WCF ReceiveActivity revisited

Maurice — Tue, 10 Mar 2009 12:42:15 GMT

Last year Marcel and I worked on a problem using a TransactionScopeActivity inside a WCF ReceiveActivity. I blogged a number of time about our finding, for example here.

Last week I heard from Marcel that a hotfix was finally available that solves this problem. He blogged about it here. Great work to see there is a fix for this serious problem.

Enjoy!

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

And now on Twitter at http://twitter.com/mauricedb.

Looking back at the MVP Summit

Maurice — Sat, 07 Mar 2009 11:08:09 GMT

Last week lots of MVP, myself included, where in Redmond visiting Microsoft on our yearly MVP pilgrimage. The MVP Summit is always a great event. Not only do we get to talk to the MS team members who actually design and build all the software we love and use but we also get to meet each other. And with MVP’s being located around the world that is kind of rare as well.

Despite this being a great event I still have very mixed feelings about this last MVP summit. The problem isn’t the events itself or the people I met, that was al great . No the problem was in some of the technological decisions made in product groups. Unfortunately I can’t divulge details yet because I have signed an NDA but as soon .NET 4.0 as beta 1 is made public I will be able to blog about some of these decisions. And rest assured I will!

The reason we really need to is the way these important changes are communicated. Or should I say not communicated. Some very important changes where not communicated at all and could only be derived by bullet points missing from PowerPoint slides. Only when directly asked about the missing bullet point would someone say “Yes that is right, we decided to …. NDA … because … NDA …”. Sorry about the NDA part .

I can only say that these decisions are a big problem and I know several MVP’s who decided to skip other sessions on the same product as a result. I didn’t, as far as I am concerned ignoring a problem is not going to make it go away, but I really think this product team needs to reevaluate this decision and the general future trend.

Despite this hiccup I am very exited about lots of the things I got to see and am really looking forward to .NET 4 and Visual Studio 2010. Now if we only could have a beta today . When we will have a first beta is still a big question though. If a date was announced I missed it, the best I heard was a quarter and is quite a time span.

Enjoy.

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

Presenting at VB Central

Maurice — Tue, 03 Mar 2009 13:46:17 GMT

Next week, on march 10th, I will be doing a presentation on getting started with WCF at the VB Central user group in the Netherlands. Its a free event so if you are in the neighborhood feel free to drop by. They do ask you register beforehand. Besides my session on WCF there will also be a session on using WPF and data binding.

Mode details and the registration page can be found here.

Hope to see you there.

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

Handling HTTPS SSL certificate errors

Maurice — Sat, 21 Feb 2009 20:19:05 GMT

When using self created SSL certificates with HTTPS WCF endpoints you might run into certificate validation errors. The best solution of to make sure all your certificates are fully trusted but sometimes that might not be an easy thing. The next best thing is to the the ServicePointManager.ServerCertificateValidationCallback and have add your own function to validate the certificate. This way you can ignore invalid certificates and keep going as if everything is well.

Take care though as this might open up a can of worms in a production environment.

Enjoy!

www.TheProblemSolver.nl
Wiki.WindowsWorkflowFoundation.eu

Patterns & Practices release Prism version 2

Maurice — Wed, 18 Feb 2009 19:01:01 GMT

The Patterns & Practices group at Microsoft have just released Prism version 2. I am pretty exited about this because Prism version 2 supports both WPF and Silverlight. And as it makes extensive use of the Model - View - ViewModel amongst other design patterns it is a great place to learn, even if you don't use it as is.

Check out the main "Composite Application Guidance for WPF and Silverlight" page here. Or read Blaine Wastell about it here.

Enjoy!

Lazy loading using Ninject

Maurice — Tue, 10 Feb 2009 06:13:00 GMT

In my previous blog post I demonstrated how you can use Ninject in your Silverlight application to automatically inject dependencies and make live easier. In the sample I injected the dependency, the PingService, inside my PageModel constructor. That worked just fine because the PingService is lightweight and stateless. However suppose creation is much more involved and you don’t need it all the time so you really want to divert creation until you really need the PingService. Well we can by just a few simple changes.

Changing the PageModel to defer loading of the PingService

This is actually a very easy change. All we need to do is change to constructor from expecting a PingService to expecting a IKernel. The IKernel is the Ninject main object and Ninject will take care of injecting itself. Kind of cool as the Page, which creates and uses the PageModel , doesn’t even need to be aware of the change, Ninject will do all the work here .

Now we can change the ExecutePing() function to use the kernel to create the PingService when needed and we are done. The new PageModel looks like this:

using System;
using System.ComponentModel;
using System.Threading;
using Ninject.Core;
 
namespace NinjectSample
{
    public class PageModel : INotifyPropertyChanged
    {
        public PageModel(IKernel kernel)
        {
            _kernel = kernel;
            _context = SynchronizationContext.Current;
        }
 
        private IKernel _kernel;
        private SynchronizationContext _context;
        public DateTime TheResult { get; set; }
 
        public void ExecutePing()
        {
            PingService.PingService proxy = _kernel.Get<PingService.PingService>();
            proxy.BeginPing(proxy_PingCompleted, proxy);
        }
 
        void proxy_PingCompleted(IAsyncResult result)
        {
            PingService.PingService proxy = (PingService.PingService)result.AsyncState;
            _context.Post(state =>
                {
                    TheResult = proxy.EndPing(result);
 
                    if (PropertyChanged != null)
                        PropertyChanged(this, new PropertyChangedEventArgs("TheResult"));
                }, null);
        }
 
        public event PropertyChangedEventHandler PropertyChanged;
    }
}

The normal generated WCF PingService will work just fine as will the Page, no changes there. The only other change we need to make is to the TestPingService as this was a very simple implementation before. Not that it is very complicated now but it needs to work with a dummy IAsyncResult. The complete fake code looks like this:

using System;
 
namespace NinjectSample
{
    public class TestPingService : PingService.PingService
    {
        public IAsyncResult BeginPing(AsyncCallback callback, object asyncState)
        {
            TestAsyncResult result = new TestAsyncResult() { AsyncState = asyncState };
            callback(result);
            return result;
        }
 
        public DateTime EndPing(IAsyncResult result)
        {
            // Birthdate Charles Babbage
            return new DateTime(1791, 12, 26);
        }
    }
 
    class TestAsyncResult : IAsyncResult
    {
        public object AsyncState { get; set; }
        public System.Threading.WaitHandle AsyncWaitHandle { get; set; }
        public bool CompletedSynchronously { get; set; }
        public bool IsCompleted { get; set; }
    }
}

Easy right

Conclusion

Even though we are now using lazy loading instead of eager loading Ninject still makes live easy for us.

Enjoy!

Download source code

Using Ninject with Silverlight to make you code more testable

Maurice — Mon, 09 Feb 2009 12:16:13 GMT

One useful feature when developing more complex code is using an inversion of control (IOC) container to do dependency injection. The basic principal of inversion of control, or dependency injection, is to pass in any dependencies when an object is created and not create them when needed. This way the code is much more decoupled and much easier to unit test.

Dependency injection with Silverlight

When developing regular .NET code there are plenty of IOC containers to choose from. However when it comes down to Silverlight the choice isn’t quite as big. I am aware of only two IOC containers you can use with Silverlight, Ninject and Unity. In this example I am going to use Ninject but the same approach would be perfectly valid using Unity.

The basic application

I am going to use a very basic application to demonstrate using Ninject with Silverlight. Just a TextBlock and Button on the form and when the button is called we are going to call a WCF service and call a ping method returning the current time.

The page is real simple. All I do is create a PageModel, make it the DataContext for the form and call the ExecutePing function when the button is clicked.

     using System.Windows;

    using System.Windows.Controls;

    namespace NinjectSample

    {

        public partial class Page : UserControl

        {

            private PageModel _model;

            public Page()

            {

                InitializeComponent();

                _model = new PageModel();

                DataContext = _model;

            }

            private void Button_Click(object sender, RoutedEventArgs e)

            {

                _model.ExecutePing();

            }

        }

    }

The PageModel class is also very straightforward and looks like this:

    using System;

    using System.ComponentModel;

    using NinjectSample.PingService;

    namespace NinjectSample

    {

        public class PageModel: INotifyPropertyChanged

        {

            public DateTime TheResult { get; set; }

            public void ExecutePing()

            {

                PingServiceClient proxy = new PingServiceClient();

                proxy.PingCompleted += proxy_PingCompleted;

                proxy.PingAsync();

            }

            void proxy_PingCompleted(object sender, PingCompletedEventArgs e)

            {

                TheResult = e.Result;

                if (PropertyChanged != null)

                    PropertyChanged(this, new PropertyChangedEventArgs("TheResult"));

            }

            public event PropertyChangedEventHandler PropertyChanged;

        }

    }

So this works but there is a problem. This code is not very testable as it creates the PingServiceClient, which calls the server, while executing. Lets see how we can refactor this using Ninject to create a bit more maintainable and testable code.

Adding Ninject

First make sure you download the Silverlight version of Ninject from the website here. And add a reference to the DLL’s from the Silverlight project.

So lets do the minimum work to use Ninject and have it insert the dependency. Instead of using the new operator to create the PageModel we are going to let Ninject handle this using the following code:

IKernel kernel = new StandardKernel();

_model = kernel.Get<PageModel>();

And to have Ninject inject the dependency on the WCF service we are going to change it to receive he proxy object in the constructor like this:

    public class PageModel : INotifyPropertyChanged

    {

        public PageModel(PingServiceClient proxy)

        {

            _proxy = proxy;

        }

        private PingServiceClient _proxy;

        public DateTime TheResult { get; set; }

        public void ExecutePing()

        {

            _proxy.PingCompleted += proxy_PingCompleted;

            _proxy.PingAsync();

        }

        void proxy_PingCompleted(object sender, PingCompletedEventArgs e)

        {

            _proxy.PingCompleted -= proxy_PingCompleted;

            TheResult = e.Result;

            if (PropertyChanged != null)

                PropertyChanged(this, new PropertyChangedEventArgs("TheResult"));

        }

        public event PropertyChangedEventHandler PropertyChanged;

    }

A few small changes and everything still works exactly as before.

So what did we gain? Only the fact that the dependency between the PageModel and the PingServiceClient is slightly decoupled. However because we are still using concrete classes and the PingAsync() is not virtual we have gained very little.

Making the code more testable

In order to make the code more testable we need to start using the PingService interface instead of the PingServiceClient concrete type. So lets make some changes to the code. First of all we need to change the PageModel class to use the interface. This means we can no longer use the PingAsync function and PingCompleted event as they are part of the concrete class. Instead we have to use the BeginPing() and EndPing() functions.

One extra complication here is that the standard generated proxy makes sure the callback event is raised on the right thread, something we now have to take care of using a SynchronizationContext.

The new PageModel looks like this:

    using System;

    using System.ComponentModel;

    using System.Threading;

    namespace NinjectSample

    {

        public class PageModel : INotifyPropertyChanged

        {

            public PageModel(PingService.PingService proxy)

            {

                _proxy = proxy;

                _context = SynchronizationContext.Current;

            }

            private PingService.PingService _proxy;

            private SynchronizationContext _context;

            public DateTime TheResult { get; set; }

            public void ExecutePing()

            {

                _proxy.BeginPing(proxy_PingCompleted, null);

            }

            void proxy_PingCompleted(IAsyncResult result)

            {

                _context.Post(state =>

                    {

                        TheResult = _proxy.EndPing(result);

                        if (PropertyChanged != null)

                            PropertyChanged(this, new PropertyChangedEventArgs("TheResult"));

                    }, null);

            }

            public event PropertyChangedEventHandler PropertyChanged;

        }

    }

With this in pace we need to configure Ninject a bit so it knows which object to create as the PingService. If we forget to do so we will see a Ninject.Core.ActivationException with the following message:

Error activating PingService: no matching bindings are available, and the type is not self-bindable (or implicit binding is disabled).
Activation path:
1) active request for PingService

Configuring Ninject

The way to configure Ninject is to create a module loader class derived from StandardModule and implement the Load() function specifying the dependencies like this:

    using Ninject.Core;

    using NinjectSample.PingService;

    namespace NinjectSample

    {

        public class PingModule : StandardModule

        {

            public override void Load()

            {

                Bind<PingService.PingService>().To<PingServiceClient>();

            }

        }

    }

Next we need to tell Ninject which module to use by passing it into the constructor like this:

public Page()

    InitializeComponent();

    IKernel kernel = new StandardKernel(new PingModule());

    _model = kernel.Get<PageModel>();

    DataContext = _model;

And again everything is working again

Adding a test service

Now we have fully decoupled the pageModel from the service we can create a test service so we execute the code without actually calling the WCF service.

First we need to create a test service like this:

    using System;

    namespace NinjectSample

    {

        public class TestPingService : PingService.PingService

        {

            public IAsyncResult BeginPing(AsyncCallback callback, object asyncState)

            {

                callback(null);

                return null;

            }

            public DateTime EndPing(IAsyncResult result)

            {

                // Birthdate Charles Babbage

                return new DateTime(1791, 12, 26);

            }

        }

    }

The code is simple and just returns a fixed date.

Next we need to tell Ninject which implementation to use. There are several ways to do this. I suppose the best is to create a specific module for testing but in this case I have taken the route of conditionally binding dependencies in a single module like this:

    using Ninject.Core;

    using NinjectSample.PingService;

    namespace NinjectSample

    {

        public class PingModule : StandardModule

        {

            private bool _testMode;

            public PingModule(bool testMode)

            {

                _testMode = testMode;

            }

            public override void Load()

            {

                Bind<PingService.PingService>().To<PingServiceClient>()

                    .OnlyIf(p => _testMode == false);

                Bind<PingService.PingService>().To<TestPingService>()

                    .OnlyIf(p => _testMode == true);

            }

        }

    }

Now I can vary the behavior by just passing in true or false when creating the Ninject module.

Conclusion

Using Ninject, or another IOC container, makes it easier to test code. Of course Ninject isn’t a silver bullet here, the same effect could be achieved with manual injection. But thinking about dependencies this way makes code easier to develop and test. And why do dependency inject by hand if an IOC container like Ninject can do it for you!

Enjoy!

Source code download

Gotcha with HostingEnvironment.MapPath()

Maurice — Sun, 08 Feb 2009 17:39:24 GMT

When developing WCF service the System.Web.Hosting.HostingEnvironment class is kind of useful as it will give you all sorts of information about the runtime environment of where you app is hosted.

string path = HostingEnvironment.MapPath(@"\MyFile.txt");

Now the problem is it only works when the service is hosted inside IIS, or the Cassini development server that comes with VS2008, not when the service is self hosted. Guess that makes sense but it is kind of easy to start with a WCF Service Library project template, even when you finally intend to host the service under IIS.

The problem is that the development service, WcfSvcHost.exe, acts as if it is running as a self hosting app and does not let you use the HostingEnvironment members.

So I guess it is better to always start with a WCF Service Application which acts more like an IIS hosted application.

Enjoy!

Returning exception information to a Silverlight client through WCF

Maurice — Tue, 27 Jan 2009 18:19:21 GMT

Error handling code can be a drag but the simple fact is that everyone needs to write it because runtime errors can and do occur. Developing a Silverlight app is no different here, exceptions will occur and you as a developer will need to deal with them.

One of the common things in Silverlight is communicate with a server through WCF and as soon as we start executing code on the server that is just another place where errors can occur. No big deal you might think as that is the same with any other application using WCF. Well the fact that it will also happen in other applications is certainly true but unfortunately the way Silverlight communicates with a WCF service makes live a bit more difficult.

But wait, WCF supports a FaultContract so we can just return exceptions as faults right?

Wrong

Unfortunately the Silverlight WCF stack doesn’t support a service contract with a fault contact and just adding the FaultContract attribute will make the service unusable for Silverlight clients. Even when no faults are returned

So the standard WCF faults are out, what else?

Well can’t we just throw an exception and have that resurface in the Silverlight client? Unfortunately we can’t. Even though the server WCF stack returns the exception just fine, see the Fiddler output, the browser will not pass the information on to the client and inside of Silverlight all we see is a CommunicationException with the very helpful message “The remote server retuned an error: NotFound”. Less than useful

So this code will not work

[OperationContract]

public IList<Customer> GetCustomersWithException()

    IList<Customer> result = GetCustomers();

    throw new FaultException<ArgumentException>(

        new ArgumentException("This is my error text."));

    return result;

So is there no solution?

Well there are a few examples out there that tag an Error property onto the data returned. Guess that works but I kind of don’t like it for a few reasons:

It means you cannot have a simple return value, it must always be a more complicated custom type.
You are mixing good and bad data into the same object and presumably only a single set will be filled.
It therefore breaks the single responsibility rule.

So a better solution would be to return two items instead of one.

Turns out we can use out parameters with WCF and they will be wrapped just fine into the return message. So we can return the error information using an out parameter. Great, feels like a much better design

So my first thought was to send the exception as the out parameter and the Silverlight client would get all error information that way. Turns out that didn’t work all that well. Even though the error was passed to the client the message shown in the client was always the default message and not the one actually send. And a second problem was that the parameter type had to mach the exact exception passed. using the KnownType attribute didn’t help there.

So instead of sending the original exception I decided to create a small wrapper type, MyFaultContract, that would pass the exception type and message to the Silverlight client. This info should be more than enough in most cases.

The service operation now looks like this.

[OperationContract]

public IList<Customer> GetCustomersWithCustomError(out MyFaultContract myFault)

    IList<Customer> result = null;

    myFault = null;

try

        result = GetCustomersWithException();

    catch (FaultException<ArgumentException> ex)

        myFault = new MyFaultContract()

            FaultType = ex.Detail.GetType().FullName,

            Message = ex.Detail.Message

};

    return result;

With the following custom MyFaultContract

[DataContract]

public class MyFaultContract

    [DataMember]

    public string FaultType { get; set; }

    [DataMember]

    public string Message { get; set; }

So what does our client code look like with this extra fault contract?

private void Button_Click_2(object sender, RoutedEventArgs e)

    Service1Client proxy = GetService1Client();

    proxy.GetCustomersWithCustomErrorCompleted += (s, arg) =>

        if (arg.Error != null)

            ErrorText.Text = arg.Error.GetType().FullName +

                "\n" + arg.Error.Message;

        else if (arg.myFault != null)

            ErrorText.Text = arg.myFault.FaultType +

                "\n" + arg.myFault.Message;

        else

            DataContext = arg.Result[0];

};

    proxy.GetCustomersWithCustomErrorAsync();

Not bad. It does take an extra check as we have to check both the Error and myFault properties for errors but other than that it is exactly the same.

So not a perfect solution but it works well enough for most purposes!

Sample project

Enjoy!

Consuming an ADO.NET Data Service from Silverlight

Maurice — Tue, 06 Jan 2009 12:02:05 GMT

When developing Silverlight line of business (LOB) applications we often need to get at some data from a database. There are various ways to do so. One option that is easy to get started with with is creating an ADO.NET Entity Data Model (EDM) and exposing that entity model using an ADO.NET Data Service.

Getting started

The first thing we need to create is an ASP.NET Web Application. This is basically going to act as a container for our Data Service and our Silverlight LOB application. As you can see below I named the Web Application SLDataService.

Next we need to add the ADO.NET Entity Data Model. I already have a Northwind SQL Server database on my machine and that is the database I am going to expose to I am naming the EDM Northwind.edmx.

When the popup ask if I want to create a new EDM based on an existing database or start from scratch I selected the existing database option and pointed it at my Northwind database. This lets me select the tables I want to import. In this case I am only interested in the Customers table so that is what I am importing. By default the class name will be the same as the table name, i.e. Customers, but as Customer is a more logical name I removed the training “s”.

Next step is creating the ADO.NET Data Service to publish the entity model. Add another item to the project, this time choosing an ADO.NET Data Service and naming it Northwind.svc.

If we open the Northwind.svc.cs file we need to enter a few details before we can proceed. The first thing we need to enter is EDM class name we are going to expose. In this case that is the NorthwindEntities model. Next we need to allow callers to access the EDM. By default nothing is exposed to this is a crucial step that needs to be done in the InitializeService() function! In this case I am going to allow everything, maybe not the best solution in real live

public class Northwind : DataService<NorthwindEntities>
{
    public static void InitializeService(IDataServiceConfiguration config)
    {
        config.SetEntitySetAccessRule("*", EntitySetRights.All);
    }
}

Testing our data service

Now we should be able to test our ADO.NET Data Service in the browser. Start the project and you should see the following in the browser.

Navigate to the following URL http://localhost:4163/Northwind.svc/CustomerSet by adding CustomerSet and you should see the following customer data.

If you see an RSS feed instead of the XML go into settings and disable the feed reading view. BTW the reason the customers data is showing up as an RSS feed is because the ADO.NET Data Services uses the ATOM feed format to transmit its data using a REST approach.

Creating a Silverlight LOB client

The next step is to create a Silverlight client application to consume and display the data. Add a new project the solution of type Silverlight Application and name it SilverlightClient.

When prompted just accept the defaults and add the Silverlight application to the existing SLDataService app. Next we need to add a service reference to the Northwind ADO.NET Data Service. Call it NorthwindService.

Next we need to set up a bit of a user interface to display the list of customers. I kept this really simple and used a ListBox with a DataTemplate like this:

<UserControl x:Class="SilverlightClient.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    Width="500" Height="300">
    <Grid x:Name="LayoutRoot" Background="White">
        <ListBox x:Name="lstCustomers">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <StackPanel Orientation="Horizontal">
                        <TextBlock Text="{Binding CompanyName}" Width="250" />
                        <TextBlock Text="{Binding City}" Width="100" />
                        <TextBlock Text="{Binding Country}" Width="100" />
                    </StackPanel>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
    </Grid>
</UserControl>

The final step is to load the data from the service and bind this to the ListBox. To do that we need to create an DataServiceContext object of type NorthwindEntities. Unlike a regular service reference the DataServiceContext does not know its own URL by default and we need to be given the URL where the web service is located. Easy enough using the URL of the current page, loaded using HtmlPage.Document.DocumentUri, and the name of the service, Northwind.svc in this case.

Uri uri = new Uri(HtmlPage.Document.DocumentUri, "Northwind.svc");
NorthwindEntities context = new NorthwindEntities(uri);

Using this context object we can do a LINQ query to load some data. Pretty standard stuff except that the asynchronous nature of Silverlight changes the actual loading of the data a bit. Normally you would expect to do something like:

var query = from cust in context.CustomerSet 
            select cust;

lstCustomers.ItemsSource = query.ToList();

In this case that won’t work and will only result in an System.NotSupportedException with the following message "Specified method is not supported.".

The correct way of doing this is by using a DataServiceQuery object which can load the data asynchronously as follows:

var query = from cust in context.CustomerSet 
            select cust;

var dsQuery = (DataServiceQuery<Customer>)query;
dsQuery.BeginExecute(
    result => lstCustomers.ItemsSource = dsQuery.EndExecute(result), 
    null);

And the final result looks like this

Not bad at all

The complete code behind looks like this:

using System;
using System.Data.Services.Client;
using System.Linq;
using System.Windows;
using System.Windows.Browser;
using System.Windows.Controls;
using SilverlightClient.NorthwindService;

namespace SilverlightClient
{
    public partial class Page : UserControl
    {
        public Page()
        {
            InitializeComponent();
            Loaded += new RoutedEventHandler(Page_Loaded);
        }

        void Page_Loaded(object sender, RoutedEventArgs e)
        {
            Uri uri = new Uri(HtmlPage.Document.DocumentUri, "Northwind.svc");
            NorthwindEntities context = new NorthwindEntities(uri);
 
            var query = from cust in context.CustomerSet 
                        select cust;

            // This doesn't work and will throw an System.NotSupportedException!
            // lstCustomers.ItemsSource = query.ToList();

            var dsQuery = (DataServiceQuery<Customer>)query;
            dsQuery.BeginExecute(
                result => lstCustomers.ItemsSource = dsQuery.EndExecute(result), 
                null);
        }
    }
}

Visual Studio project sampe code

Enjoy!