In my cumbersome 2 hour session I spoke about DDD, Entity Framework and design patterns.

Please find the presentation here.

And the two projects for the presentation can be found below.

Enjoy and as usual don’t hesitate to come back with questions.

http://www.paulstovell.com/talking-shop

Richard Banks started a podcast series with a focus on Australian developers called Talking Shop. Last week he was kind enough to interview me about WPF, Magellan, and a number of other (un)related topics.

Talking Shop Episode 5

Don't forget to check out the earlier episodes:

• Paul Batum
• Joe Albahari
• Matt Hamilton
• Scott Barnes

What a read that was.

Brief:

In this complete guide to performance profiling, Paul Glavich and Chris Farrell explain why performance testing is a good idea and walk you through everything you need to know to set up a test environment. This comprehensive guide to getting started is an essential handbook to any programmer looking to set up a .NET testing environment and get the best results out of it. Download your free copy now.

Happy Testing!

Beginner Developers

A method will usually be written to achieve a single function. At least simple methods will. Methods can do that by either running some simple statements or by leveraging other methods. But for this post let’s concentrate on how you would look at a method with simple statements.

The following static method divides two numbers.

static double Divide(double x, double y)
{
    return x/y;
}

By making this method static we already decided that the method can be called without the instantiation of an object, The second step that a beginner developer will decide is usually the scope of the method. Is it private or public? Let’s say for now that the method is public.

public static double Divide(double x, double y)
{
    return x/y;
}

So far we have established the following characteristics of the method:

• The method divides two numbers.
• The method can be called without instantiating an object.
• The method can be called from outside the containing class.

Most of the time this is usually where a beginner developer would stop.

Junior Developer

A junior developer with several months experience will know that this is not the end of it. The developer will usually add more characteristics to the method and consider where the method can fail by analysing possible failure points. For example, knowing that if y is 0 the method will throw an exception the developer will arm his method with a validation mechanism. Perhaps throw an exception of his own. The junior developer can also dislike the naming strategy so he renames variables to make things clearer.

public static double Divide(double dividend, double divisor)
{
    if(divisor == 0)
    {
        throw new ArgumentException("divisor cannot be zero", "divisor");
    }
    return dividend/divisor;
}

The characteristics of the method, after being touched by the junior developer became:

• The method divides two numbers.
• The method can be called without instantiating an object.
• The method can be called from outside the containing class.
• The method is more readable.
• The method validates for a divisor being 0.

Intermediate Developer

When the developer gets to an intermediate stage he\she starts thinking about reusability and neat code. The developer wants to be able to use an extension method to facilitate calling the code from any double variable in the application with no class calls. So a static class is created and a helper extension method follows.

public static class ArithmeticHelpers
{
    public static double DivideBy(this double dividend, double divisor)
    {
        if (divisor == 0)
        {
            throw new ArgumentException("divisor cannot be zero", "divisor");
        }
        return dividend / divisor;
    }
}

The characteristics of the method, after being touched by the junior developer became:

The method divides two numbers.

The method can be called without instantiating an object.

The method can be called from outside the containing class.

The method is more readable.

The method validates for a divisor being 0.

The method is more re-usable and can be applied through any double type variable.

Senior Developer

Our developer now gets to a senior level. The developer glances over his old code and finds that the method is next to perfect. One thing he wants to make sure of, is that if any other developer changes the method with breaking changes (ones that do not meet expectations) a notification will arise. So the senior developer decides to write some unit tests trying to cover all his possibilities.

[TestMethod]
[ExpectedException(typeof (ArgumentException),
    "The Divisor cannot be zero.")]
public void DivisionTestCase1()
{
    const double num1 = 10;
    const double num2 = 0;

    num1.DivideBy(num2);
}

[TestMethod]
public void DivisionTestCase2()
{
    const double num1 = 10;
    const double num2 = 2;

    Debug.Assert(num1.DivideBy(num2) == 5);

    const double num3 = double.MaxValue;
    const double num4 = double.MinValue;

    Debug.Assert(num3.DivideBy(num4) == -1);
    Debug.Assert(double.IsInfinity(num3.DivideBy(0.1)));
    Debug.Assert(double.IsNegativeInfinity(num3.DivideBy(-0.1)));
}

Wow, our method is getting richer by the minute and the characteristics are now:

The method divides two numbers.

The method can be called without instantiating an object.

The method can be called from outside the containing class.

The method is more readable.

The method validates for a divisor being 0.

The method is more re-usable and can be applied through any double type variable.

The method is tested and unit tests will indicate any breaking changes.

Architects \ Team Leads & People you can’t Please

What an annoying bunch of people those are (just kidding for the sensitive kind :)). Now an architect looks at the method which is almost perfect and think to himself “How can I make something this good better?” The architect then identifies the “junction points of a method”. If you were at our (Paul Stovell and I) talk at CodeCampOz you would know what junction points are and those can be defined by the following diagram.

The architect now decides that the method needs to be auditable and exceptions needs to be handled by a policy. In other words, that nosy architect wants to use Aspect Oriented Programming to handle the cross cutting concerns of the method. For this he leverages PostSharp and creates a couple of aspects.

[Serializable]
public class OnDivideByInvocationAspect : OnMethodInvocationAspect
{
    public override void OnInvocation(MethodInvocationEventArgs context)
    {
        Trace.TraceInformation("Entering {0}.", context.Method); 
        context.Proceed();
        Trace.TraceInformation("Leaving {0}.", context.Method); 
    }
}

[Serializable]
public sealed class OnDivideByExceptionAspect : OnExceptionAspect
{
    public override void OnException(MethodExecutionEventArgs eventArgs)
    {
        if (eventArgs.Exception.GetType() == typeof(ArgumentException) &&
            eventArgs.Exception.Message.Equals("The Divisor cannot be zero."))
        {
            Trace.TraceInformation(eventArgs.Exception.Message);
        }

        eventArgs.FlowBehavior = FlowBehavior.RethrowException;
    }
}

Now our method looks something like this.

[OnDivideByExceptionAspect]
[OnDivideByInvocationAspect]
public static double DivideBy(this double dividend, double divisor)
{
    if (divisor == 0)
    {
        throw new ArgumentException("The Divisor cannot be zero.", "divisor");
    }
    return dividend / divisor;
}

Only thing is when you thought it’s almost over, another architect does a further refinement to the exception aspect and wants less code in the method so now he goes and….does this.

[Serializable]
public sealed class OnDivideByExceptionAspect : OnExceptionAspect
{
    public override void OnException(MethodExecutionEventArgs eventArgs)
    {
        if (eventArgs.Exception.GetType() == typeof(DivideByZeroException))
        {
            Trace.TraceInformation(eventArgs.Exception.Message);
        }

        eventArgs.FlowBehavior = FlowBehavior.RethrowException;
    }
}

and now the method looks like:

[OnDivideByExceptionAspect]
[OnDivideByInvocationAspect]
public static double DivideBy(this double dividend, double divisor)
{
    return dividend / divisor;
}

Wow almost a full circle and now one more characteristic is:

• The method divides two numbers.
• The method can be called without instantiating an object.
• The method can be called from outside the containing class.
• The method is more readable.
• The method validates for a divisor being 0. (but with a twist)
• The method is more re-usable and can be applied through any double type variable.
• The method is tested and unit tests will indicate any breaking changes.
• The code is concise to the problem at hand – division.

Conclusion

I wrote this post inspired by various discussion with developers over @ Datacom. The boundaries I drew between the different levels of developers here are only an example and do not necessarily resemble real life. This post was also never meant to say the applying AOP is always the perfect end solution. I wrote this post to point your attention to the importance of investing time in the quality of your simplest and smallest building block, the method. The method shown in this post is a simple division one yet we managed to think about it and implement it in various ways. Everyday in your coding life, pay attention to your methods. The journey didn’t finish when the fictitious architect was done with applying AOP nor do the steps in this post conclude your ‘method perfection journey’. Of the top of my head I think this method is yet to be performance tested, memory profiled and dependency analysed :)

Your method is your core building block. If it is of high quality then you got more chance of success with whatever software you’re building. I believe if you just spend 5 minutes gazing at a method after you wrote it, you will have more chance of making it better.

Enjoy!

My Participation

This year witnessed my biggest participation so far in TechEd. With a Tech Talk with Paul Glavich and a WPF Composite Framework breakout session and two Bird of Feathers sessions I couldn’t possibly be any happier.

Tech Talk: Enterprise Software

The master of disaster, fellow Architect Paul Glavich took the time to interview me and it was fun talking Enterprise Applications with the man who knows it all. Check out the video here.

Breakout Session: WPF Composite Framework

For a while now I have been using the Composite Framework to architect and build rich client applications and a shout out goes to Paul Stovell who showed me this for the first time. I took the audience on a trip around the concepts and implementations of the Composite Framework. While the feedback was a bit mixed I think for a wide topic the audience managed to see the benefit of the Composite framework in building modular interfaces. All the code can be downloaded here.

BOF Sessions : PostSharp & LightSpeed

I also got to do a couple of short sessions on PostSharp (http://www.postsharp.org/) and LightSpeed (http://www.mindscape.co.nz/products/lightspeed/ ). Again a big shout out goes out to the guys from Mindscape for providing free licences to give away during the session. You can download the code for the PostSharp Session here.

Conclusion

and as usual not to be forgotten the boys from Readify and their ever entertaining company

WEB305 Modular User Interfaces: Easier than Ever (Thu 9/10 | 11:30-12:45 | Arena 1B)

BOF006 LightSpeed: An ORM not to be missed. (Fri 9/11 | 12:45-13:45 | Meeting Room 7)

Lightning Talk about PostsSharp on Thursday Lunch time with Richard Bank and the Alt.NET exponanza and a tech talk with the Amazing Paul Glavich.

Here are some photos from today:

Looking forward to CodeCampSA next weekend where I will be presenting on the Sync Framework.

In this post I am hoping to show a step by step approach to create a bidirectional synchronization line between a products table on my client and one on my SQL 2008 server that site behind a WCF service. Directly from MSDN this image shows what we try to achieve http://msdn.microsoft.com/en-us/library/bb902831.aspx.

Note: This is not an entry post of the sync framework. It’s just an explanation how to use sync framework, WCF and SQL 2008. Source code available at the end of the post.

Install the Sync Framework

Please download and install the sync framework found here.

My DB

Nothing fancy to see here, just your good old product table with a couple of rows.

There is a key thing to mention here before I continue. If you are using an SQL Server older than 2008 you will need to be manual change tracking as explained in the link to the MSDN article above. Otherwise SQL 2008 has got built in change tracking features which provide sufficient change tracking information to our scenario. One option in your database you have to make sure is on, is that tracking of changes is enabled. Right Click your database and click properties.

I created a data dude project in my solution for simplicity of distributing the demo’s source code.

My Sync Service – Part 1

The first thing I need to do here is to create a WCF project and add the following dlls as references. This will be my sync service.

1. Microsoft.Synchronization.dll
2. Microsoft.Synchronization.Data.dll
3. Microsoft.Synchronization.Data.Server.dll

I then create the following service definition for my Sync Service. These methods (service operations) and their signatures are what my client is going to be expecting when attempting a sync back to the server.

using System.Collections.ObjectModel;

using System.Data;

using System.Net.Security;

using System.ServiceModel;

using Microsoft.Synchronization.Data;



namespace WcfSyncService

{

  [ServiceContract(Name = "SyncService", SessionMode = SessionMode.NotAllowed,

    ProtectionLevel = ProtectionLevel.EncryptAndSign)]

  public interface ISyncService

  {

    [OperationContract]

    SyncContext ApplyChanges(SyncGroupMetadata groupMetadata, DataSet dataSet, SyncSession syncSession);



    [OperationContract]

    SyncContext GetChanges(SyncGroupMetadata groupMetadata, SyncSession syncSession);



    [OperationContract]

    SyncSchema GetSchema(Collection<string> tableNames, SyncSession syncSession);



    [OperationContract]

    SyncServerInfo GetServerInfo(SyncSession syncSession);

  }

}

My Sync Client – Part 1

Now I come up with a WPF client that displays a list of items from the local cache at any given time. The idea will be to synchronise the local cache with my server’s database through the WCF service we defined earlier.

So I start off with a simple WPF App.

I now need to add my local cache database.

I now get presented with the following wizard. I choose the server’s connection string and a new client database option is given to me. I then change the project location of the server to my previously created WCF service project.

From there I choose the products table to create a local dataset. The steps are outlined as follows.

Select the field I want to include in my typed data table.

Viola! Not only did the client create the appropriate cache on the client but it also created the necessary sync providers and adapters in the service project as well.

The thing to note here is that my client is still not configured to sync with the server. For that I will need to do some minor code changes.

My Sync Service – Part 2

Jumping back to the server I need to now implement my service definition. I do that by passing all of the operation on to the Sync provider that has now been created for me by the wizard.

using System.Collections.ObjectModel;

using System.Data;

using Microsoft.Synchronization.Data;



namespace WcfSyncService

{

  public class SyncService : ISyncService

  {

    private readonly ProductCacheServerSyncProvider syncProvider;



    /// <summary>

    /// Initializes a new instance of the <see cref="SyncService"/> class.

    /// </summary>

    public SyncService()

    {

      syncProvider = new ProductCacheServerSyncProvider();

    }



    public SyncContext ApplyChanges(SyncGroupMetadata groupMetadata, DataSet dataSet, SyncSession syncSession)

    {

      return syncProvider.ApplyChanges(groupMetadata, dataSet, syncSession);

    }



    public SyncContext GetChanges(SyncGroupMetadata groupMetadata, SyncSession syncSession)

    {

      return syncProvider.GetChanges(groupMetadata, syncSession);

    }



    public SyncSchema GetSchema(Collection<string> tableNames, SyncSession syncSession)

    {

      return syncProvider.GetSchema(tableNames, syncSession);

    }



    public SyncServerInfo GetServerInfo(SyncSession syncSession)

    {

      return syncProvider.GetServerInfo(syncSession);

    }

  }

}

My Sync service is now ready to roll and I load in the wcf test client just to make sure everything is alright.

OK so the mental note here is the service does load and it does run but the parameters are not supported by the WCF test client.

My Sync Client – Part 2

Ok now my WCF service is ready. The next step is to configure the client to use the WCF service for the synchronization. I now add a service reference to my service from the client.

One more thing to note here. The wizard will always create SyncTables with a default SyncDirection of DownloadOnly. But in this scenario we need the table updates to be Bidirectional.  The trick is to right click the ProductCache and click on View Code. A partial class is created and you need to modify it as follows.

using Microsoft.Synchronization.Data;



namespace WcfSyncClient {

  

  

  public partial class ProductCacheSyncAgent 
{

    

    partial void OnInitialized()

    {

      this.Product.SyncDirection = SyncDirection.Bidirectional;

    }

  }

}

Ok so now all my infrastructure is ready so time for a semi pretty UI for the display of data and operations.

It’s pretty simple what happens behind these buttons. The main thing to note is that I am instantiating the agent using my WCF client proxy. This basically tells the sync agent to use my WCF service for any synchronisations.

using System;

using System.Windows;

using Microsoft.Synchronization.Data;

using WcfSyncClient.SyncDBDataSetTableAdapters;

using WcfSyncClient.SyncServiceProxy;



namespace WcfSyncClient

{

  /// <summary>

  /// Interaction logic for Shell.xaml

  /// </summary>

  public partial class Shell : Window

  {

    public Shell()

    {

      InitializeComponent();

    }



    private void btnRefresh_Click(object sender, RoutedEventArgs e)

    {

      var ds = new SyncDBDataSet();

      var adapter = new ProductTableAdapter();

      adapter.Fill(ds.Product);

      listBox.DataContext = ds;

    }



    private void btnSynchronise_Click(object sender, RoutedEventArgs e)

    {

      var syncAgent = new ProductCacheSyncAgent(new SyncServiceClient());

      SyncStatistics syncStats = syncAgent.Synchronize();

    }



    private void btnAddRow_Click(object sender, RoutedEventArgs e)

    {

      var ds = (SyncDBDataSet) listBox.DataContext;

      var dr = ds.Product.NewRow() as SyncDBDataSet.ProductRow;

      if (dr != null)

      {

        dr.Name = "New Product " + (new Random()).Next();

        dr.ProductId = Guid.NewGuid();

        dr.Price = 800;

        ds.Product.AddProductRow(dr);



        var adapter = new ProductTableAdapter();

        adapter.Update(ds);

      }

    }

  }

}

I can see by running the application the SQL DB is also getting that changes as I add new records on the client and vice versa.

One Problem You Might Run Into

One exception that you might get during debugging your application on 64-bit machines is:

Unable to load DLL 'sqlceme35.dll': The specified module could not be found.

This is related to the fact that the original release SqlCe was not supported on 64-bit machines. You have two options:

1. Download Microsoft SQL Server Compact 3.5 Service Pack 1 and Synchronization Services for ADO.NET version 1.0 Service Pack 1 for Windows Desktop
2. Compile your project for x86 CPU configuration.

Clearly the first option is the recommended one.

Source Code

Conclusion

The sync framework is a nice tool and toy that simplifies a lot of the hassles we had to go through in the past for offline data caching. Bundling it with WCF just gives it a fantastic edge. It should not be missed in your future projects.