Southworks Blogs

End of Iteration ;)

aschapiro — Fri, 03 Feb 2012 23:40:37 +0000

As some of you know, I’m closing a chapter of my professional life in Southworks today and starting a new one in Microsoft Argentina (DPE) from next week.

It’s been a 6.5 years chapter actually, that started for me in an earlier version of the Southworks that exists today. I think we grew a lot, in part because of the awesome team we helped to build together and also because of the help of very talented and generous people, passionate of getting better every day. I believe the current version of Southworks is the result of that hard work: a well-respected and growing company that earned its place of high quality service, that world-changing agents trust and where many talented engineers find a place to grow and share.

Lots of projects, trips, experiences and people come to my mind now. Ale Jack, Mawolo, Fede Jack, Tincho Cacciola, TimO, Mariano S, Lito, Beto, Martin Salias, EZ, Johnny and JPG are some of the “oldest” friends here (in representation of the whole team which includes many, many awesome people that I’ve been interacting with in the last years): well let me thank you for the incredible help, guidance, support and teamwork of these years. I guess I’ll be happy in the future if I get a 1% of what I felt, grew and did at Southworks; and I guess I will because I’ll carry the Southworks flag with me.

I’m simply happy of spending my last 6.5 years working at Southworks but honestly I don’t think that our story together ends here. As I said before, this is just an End of Iteration, and I’m looking forward to keep working and growing together in the following iteration! I’ll be around, you’ll see….and we’ll keep having moments like these:

See you soon and keep it up!

How to build a basic fluent interface in 8 steps

Jorge Rowies — Wed, 01 Feb 2012 17:40:35 +0000

Disclaimer: the aim of this post is not to show a comprehensive list of the different techniques that can be used to write a fluent API, tons of good information is out there on the web and. If you are very interested in the subject, please take a look at Martin Fowler’s Domain-Specific Languages.

Now that I took that load off my back, let’s start writing a fluent interface.

Imagine we are developing an API to publish blog posts to multiple blogging platforms (Blogger, WordPress, TypePad and so on…), chances are that our (super-simplified) domain model will be something similar to this:

So, creating a new blog post should be:

var post = new BlogPost();
post.Title = "How to build a basic fluent interface in 8 steps";
post.Body = "...";

var author = new Author(); // We should check the authors repository
                           // before creating a new one
author.Name = "John Doe";
author.Email = "johndoe@email.com";
author.Twitter = "@johndoe";
post.Author = author;

post.Tags = "Fluent API, Internal DSL";

Our domain model is very simple and the code for creating a blog post is not so bad to read or write, so in this case implementing a fluent interface might be somewhat unnecessary; but… it’s perfect for us to learn how to write a fluent API. Shall we?

Step 1 – Writing a draft of the interface

Write (in notepad) a draft of the fluent interface showing how you want it to look like (don’t think too much now on how you will implement the interface, just play around with the ideas)

This is what I came up with:

var post = Post .Title("How to build a basic fluent interface in 8 steps") .Body("...") .Author() .Name("John Doe") .Email("johndoe@email.com") .Twitter("@johndoe") .Tags("Fluent API, Internal DSL");

Step 2 – Using a test-first approach

Once you found an option that satisfies you, put it into a test in Visual Studio and add the code you will need to validate the outcome of the fluent interface. Depending on the size of the API, you might want to do this gradually. In this case, we are going to leave the “Author” part out of the scope for now.

In the code below we are creating two BlogPost instances, the first one using the standard API and the second one using our new fluent API. After both instances are created, they are passed to the CheckEquivalence method. This method should check if both instances of BlogPost have the same title, body and tags.

[TestCase]
public void ConfiguringPostWithoutAuthor()
{
    var expected = new BlogPost();
    expected.Title = "How to build a basic fluent interface in 8 steps";
    expected.Body = "...";
    expected.Tags = "Fluent API, Internal DSL";

    var post = Post
        .Title("How to build a basic fluent interface in 8 steps")
        .Body("...")
        .Tags("Fluent API, Internal DSL");
    BlogPost actual = post.Build();

    Assert.IsTrue(TestsHelper.CheckEquivalence(expected, actual));
}

This test, of course, won’t even compile.

Step 3 – Starting to implement the interface

Now, let’s start implementing the Post class. Note that the Title method is static so we can call it without creating a new instance of Post.

public class Post
{
    public static Post Title(string title)
    {
        var post = new Post();
        post.TitleValue = title;
        return post;
    }
}

Step 4 – Adding more methods to the fluent interface

Once we have our starting point, continue adding the remaining methods (this time as instance methods, not static).

public class Post
{
    ...

    public Post Body(string body)
    {
        this.BodyValue = body;
        return this;
    }

    public Post Tags(string tags)
    {
        this.TagsValue = tags;
        return this;
    }
}

Returning the same instance of the object we are building after each method call is one of the most common techniques used to write fluent interfaces, it’s called Method Chaining.

Step 5 – Completing the first iteration and running tests

Now, let’s implement the Build method by creating an instance of BlogPost based on the values provided with the fluent interface.

public class Post
{
    ...

    public BlogPost Build()
    {
        var blogPost = new BlogPost();

        blogPost.Title = this.TitleValue;
        blogPost.Body = this.BodyValue;
        blogPost.Tags = this.TagsValue;

        return blogPost;
    }
}

Our test should be green now!

Step 6 – Don’t forget the Author

Here comes the tricky part, let’s add the Author now…

If we continue what we’ve been doing with the Title, Body and Tags methods, we should make Author return an instance of Post; but if we do that, we should put the methods Name, Email and Twitter in the Post class, and we don’t want that. What we want is having those methods in a separate class, so instead of returning an instance of Post we are going to return an instance of a new class (AuthorSpec). Let’s try it.

public class Post
{
	...

	public AuthorSpec Author()
	{
		var authorSpec = new AuthorSpec();
		return authorSpec;
	}
}

public class AuthorSpec
{
	public AuthorSpec Name(string name)
	{
		this.NameValue = name;
		return this;
	}

	public AuthorSpec Email(string email)
	{
		this.EmailValue = email;
		return this;
	}

	public AuthorSpec Twitter(string twitter)
	{
		this.TwitterValue = twitter;
		return this;
	}
}

Now let’s create a new test method, adding the “Author” code:

public void ConfiguringPostWithAuthor()
{
	var expected = new BlogPost();
	expected.Title = "How to build a basic fluent interface in 8 steps";
	expected.Body = "...";
	expected.Tags = "Fluent API, Internal DSL";
	var author = new Author();
	author.Name = "John Doe";
	author.Email = "johndoe@email.com";
	author.Twitter = "@johndoe";
	expected.Author = author;

	var post = Post
		.Title("How to build a basic fluent interface in 8 steps")
		.Body("...")
		.Author()
			.Name("John Doe")
			.Email("johndoe@email.com")
			.Twitter("@johndoe")
		.Tags("Fluent API, Internal DSL");
	BlogPost actual = post.Build();

	Assert.IsTrue(CheckEquivalence(expected, actual));
}

But wait! The compiler says that the Tags method is not recognized as a member of the AuthorSpec class. That’s because we are calling Tags over the return value of Twitter, which is an AuthorSpec object instead of a Post object.

When writing fluent APIs, it is very common to bump into this kind of problems, the most used solutions for this are ending the Author specification with an “end” method, or passing a nested closure to the Author method.

Step 7 – Closing the Author specification and running more tests

Option A, using an “End” method.

public class Post
{
    ...

    public AuthorSpec Author()
    {
        this.authorSpec = new AuthorSpec(this);
        return authorSpec;
    }
}

public class AuthorSpec
{
    public AuthorSpec(Post parent)
    {
        this.parent = parent;
    }

    ...

    public Post End()
    {
        return this.parent;
    }
}

How it looks like:

var post = Post
    .Title("How to build a basic fluent interface in 8 steps")
    .Body("...")
    .Author()
        .Name("John Doe")
        .Email("johndoe@email.com")
        .Twitter("@johndoe")
        .End()
    .Tags("Fluent API, Internal DSL");

Option B, using a nested closure.

public class Post
{
    ...

    public Post Author(Action spec)
    {
        this.authorSpec = new AuthorSpec();
        spec(authorSpec);
        return this;
    }
}

How it looks like:

var post = Post
    .Title("How to build a basic fluent interface in 8 steps")
    .Body("...")
    .Author(a => a
        .Name("John Doe")
        .Email("johndoe@email.com")
        .Twitter("@johndoe"))
    .Tags("Fluent API, Internal DSL");

I personally prefer option B. I think it’s easier to read and the programmer doesn’t have to remember calling the “End” method.

After implementing one of these options, our test should be green.

Step 8 – Stepping into dangerous territories

Let’s imagine we want to force people using our API to set the author name first and then configure the email address or the twitter account, but not both (exclusive or). We can make use of interfaces to show only a filtered subset of the methods in the method chain.

public class Post
{
    ...

    public Post Author(Action spec)
    {
        this.authorSpec = new AuthorSpec();
        spec(authorSpec);
        return this;
    }
}

public interface IAuthorSpecAfterCreation
{
    IAuthorSpecAfterName Name(string name);
}

public interface IAuthorSpecAfterName
{
    IAuthorSpecAfterEmailOrTwitter Email(string email);
    IAuthorSpecAfterEmailOrTwitter Twitter(string twitter);
}

public interface IAuthorSpecAfterEmailOrTwitter
{
}

public class AuthorSpec : IAuthorSpecAfterCreation,
  IAuthorSpecAfterName, IAuthorSpecAfterEmailOrTwitter
{
    public IAuthorSpecAfterName Name(string name)
    {
        this.NameValue = name;
        return this;
    }

    public IAuthorSpecAfterEmailOrTwitter Email(string email)
    {
        this.EmailValue = email;
        return this;
    }

    public IAuthorSpecAfterEmailOrTwitter Twitter(string twitter)
    {
        this.TwitterValue = twitter;
        return this;
    }
}

This technique can become very useful, but the complexity of the API can grow quickly with so many interfaces here and there… use it with precaution.

The complete sources can be grabbed from here.

That’s it, I hope this helps

Fluent API for setting up Windows Azure ACS

Jorge Rowies — Sat, 28 Jan 2012 16:45:39 +0000

During the last couple of months I’ve been working for the p&p guys at Microsoft, developing the sample application for a new guide around Windows Azure hybrid application integration.

One of the components of the sample solution is a console application that performs all the steps required to have the ACS and Service Bus namespaces properly configured. This application uses a set of wrappers around the ACS Management Service API.

While this is a great step towards simplifying the life of the developer, after I looked at the resulting code I realized that my life could have been simplified even more. That’s why I decided to spend some of my time developing a fluent API for setting up ACS namespaces.

This is how the API looks like:

var namespaceDesc = new AcsNamespaceDescription(
	"somenamespace", "ManagementClient", "T+bQtqP21BaCLO/8D1hanRdKJF8ZYEV8t32odxP4pYk=");

var acsNamespace = new AcsNamespace(namespaceDesc);

acsNamespace
	.AddGoogleIdentityProvider()
	.AddServiceIdentity(
		si => si
			.Name("Vandelay Industries")
			.Password("Passw0rd!"))
	.AddRelyingParty(
		rp => rp
			.Name("MyCoolWebsite")
			.RealmAddress("http://mycoolwebsite.com/")
			.ReplyAddress("http://mycoolwebsite.com/")
			.AllowGoogleIdentityProvider()
			.SwtToken()
			.TokenLifetime(120)
			.SymmetricKey(
				Convert.FromBase64String("yMryA5VQVmMwrtuiJBfyjMnAJwoT7//fCuM6NwaHjQ1="))
			.AddRuleGroup(rg => rg
				.Name("Rule Group for MyCoolWebsite Relying Party")
				.AddRule(
					rule => rule
						.Description("Google Passthrough")
						.IfInputClaimIssuer().Is("Google")
						.AndInputClaimType().IsOfType(ClaimTypes.Email)
						.AndInputClaimValue().IsAny()
						.ThenOutputClaimType().ShouldBe(ClaimTypes.Name)
						.AndOutputClaimValue().ShouldPassthroughFirstInputClaimValue())
				.AddRule(
					rule => rule
						.Description("ACS rule")
						.IfInputClaimIssuer().IsAcs()
						.AndInputClaimType().IsAny()
						.AndInputClaimValue().IsAny()
						.ThenOutputClaimType().ShouldPassthroughFirstInputClaimType()
						.AndOutputClaimValue().ShouldPassthroughFirstInputClaimValue())));

acsNamespace.SaveChanges(logInfo => Console.WriteLine(logInfo.Message));

You can find more information in the project repository at github.

Oh, and please don’t forget to take a look at the hybrid application integration guide when it becomes available (a draft can be downloaded from here), these guys have been doing an incredible job !

That’s it, I hope this helps

Visual Studio 11 Developer Preview Training Kit

sdurandeu — Fri, 27 Jan 2012 14:37:00 +0000

If you want to get a sneak peak on what’s coming up in the next version of Visual Studio, the Visual Studio 11 Training Kit is the no brainer choice. The training kit includes hands-on labs to help you understand how to take advantage of the variety of enhancements in Visual Studio 11 and the .NET Framework 4.5.

Some of the topics included are:

What’s new in ASP.NET MVC 4 – this lab shows how to use jQuery Mobile together with new MVC 4 features, to make a Web app work great across different mobile devices and desktop web browsers
What’s new in ASP.NET Web Forms
Page Inspector – a new tool that brings browser diagnostics tools to Visual Studio 11
New Visual Studio 11 IDE features – including a whole lab for showing C++ development enhancements
WCF Web API
Async programming in .NET Framework 4.5 – showing the new async and await keywords
Portable Class Libraries support
Application Lifecycle Management features in Visual Studio 11 – see more of this in Brian Keller’s Blog (Microsoft Evangelist)

You can download the kit here: http://www.microsoft.com/download/en/details.aspx?id=27738 or view it online here: http://msdn.microsoft.com/en-us/VS11TrainingCourse.

But if you want a quick preview, in this Channel 9 video, Robert Green walks through the different flavors of the kit and the content itself.

How to: Use Application Library Caching in Prism modules

Guido Leandro Maliandi — Fri, 20 Jan 2012 20:18:42 +0000

Imagine you have a Silverlight application with functionality that is likely to change over time, but that application depends on some possibly heavyweight libraries that aren’t going to change. Every single change in your code would cause users to download the entire XAP file again, including those heavy libraries that didn’t change.

To address this concern, it’s possible to leverage Application Library Caching, which involves separating those libraries in ZIP files that are outside the XAP file, and should remain cached in the users’ browsers regardless of changes in the XAP. Prism supports Application Library Caching by, for example, providing the necessary metadata in the Prism assemblies to set them as external libraries.

However, when using Application Library Caching in Prism Modules, this doesn’t work out of the box. Let’s examine why this happens.

What happens with modules and Application Library Caching?

Agustin Adami and I examined the way Prism loads the content of module’s XAP files and found that the XapModuleTypeLoader reads the AppManifest.xaml file inside the module’s XAP file, searches for the Deployment.Parts elements and then loads the assemblies corresponding to the ones specified in the Source property of the AssemblyPart elements in the aforementioned XML element. However, dependencies that have been placed on a ZIP file using Application Library Caching are referenced in ExtensionPart elements inside the Deployment.ExternalParts element, and the physical file is stored outside the module’s XAP file (which is the only thing downloaded at this point.)

To illustrate this, here’s how the AppManifest for a certain module might look like:

 1 <Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment" (...)>
 2   <Deployment.Parts>
 3     <AssemblyPart x:Name="SomeModule" Source="SomeModule.dll" />
 4     <AssemblyPart x:Name="Infrastructure" Source="Infrastructure.dll" />
 5   Deployment.Parts>
 6   <Deployment.ExternalParts>
 7     <ExtensionPart Source="System.Windows.Controls.Data.Input.zip" />
 8     <ExtensionPart Source="System.ComponentModel.DataAnnotations.zip" />
 9   Deployment.ExternalParts>
10  Deployment>

Now, when a module’s XAP file has been downloaded, the XapModuleTypeLoader.HandleModuleDownloaded method is called, which loads in memory the results obtained by calling the XapModuleTypeLoader.GetParts method. This method ignores the Deployment.ExternalParts element inside the AppManifest.xaml file (as seen in the code snippet above):

 1 (...)private static IEnumerable<AssemblyPart> GetParts(Stream stream)
 2         {
 3             List<AssemblyPart> assemblyParts = new List<AssemblyPart>();
 4 
 5             var streamReader = new StreamReader(Application.GetResourceStream(new StreamResourceInfo(stream, null), new Uri("AppManifest.xaml", UriKind.Relative)).Stream);
 6             using (XmlReader xmlReader = XmlReader.Create(streamReader))
 7             {
 8                 xmlReader.MoveToContent();
 9                 while (xmlReader.Read())
10                 {
11                     if (xmlReader.NodeType == XmlNodeType.Element && xmlReader.Name == "Deployment.Parts")
12                     {
13                     // Deployment.Parts is examined, but Deployment.ExternalParts isn't
14                          using (XmlReader xmlReaderAssemblyParts = xmlReader.ReadSubtree())
15                         {
16                             while (xmlReaderAssemblyParts.Read())
17                             {
18                                 if (xmlReaderAssemblyParts.NodeType == XmlNodeType.Element && xmlReaderAssemblyParts.Name == "AssemblyPart")
19                                 {
20                                     AssemblyPart assemblyPart = new AssemblyPart();
21                                     assemblyPart.Source = xmlReaderAssemblyParts.GetAttribute("Source");
22                                     assemblyParts.Add(assemblyPart);
23                                 }
24                             }
25                         }
26 
27                         break;
28                     }
29                 }
30             }
31 
32             return assemblyParts;
33         }
34 (...)
35

The Unity Solution

As a possible workaround to avoid this problem from happening, we created a modified version of the XapModuleTypeLoader (named LibraryCachingXapModuleTypeLoader), which loads the extension parts in memory before loading the assembly parts. To do this, we modified the IFileDownloader_DownloadCompleted method to obtain an ExternalPartsLoader from the container and call its LoadExtensionParts method before calling the HandleModuleDownloaded. The ExternalPartsLoader.LoadExtensionParts method basically searches for the AppManifest.xaml inside the XAP file, downloads the ZIP files containing the extension parts and loads the corresponding libraries in memory. Once this operation has finished, the HandleModuleDownloaded (which had been passed as a callback) is called, and the module loading process continues as it would regularly do.

To make this work, we had to create a class that inherits from ModuleManager and overrides its ModuleTypeLoaders property to use the LibraryCachingXapModuleTypeLoaderWith class instead of the regular XapModuleTypeLoader. We then overrode the ConfigureContainer method in the bootstrapper to register this custom module manager (named LibraryCachingModuleManager) in the container, so that it is used instead of the regular one.

You can find a sample that contains all the aforementioned modifications in my Skydrive account under the name LibraryCachingSupport.zip. This sample contains a Shell project and a module; both of which use Application Library Caching.

The MEF Solution

In the MefXapModuleTypeLoader a DeploymentCatalog is used to download the module’s XAP file and then compose all the parts defined in that file. Unlike in the XapModuleTypeLoader, it’s not possible to insert the external parts loading logic in the middle, so for this workaround, we had to opt out of the DeploymentCatalog and implement a similar functionality using the LibraryCachingXapModuleTypeLoader class.

Basically, the main aspect that should be considered for the MEF version is that the DeploymentCatalog, aside from loading the modules in memory, composes the parts discovered in it into the container. So, we added the logic to do so in both the LibraryCachingMefXapModuleTypeLoader and the MefExternalPartsLoader:

 1 private static void ComposePartsInContainer(Assembly assembly)
 2         {
 3             var catalog = new AssemblyCatalog(assembly);
 4 
 5             var batch = new CompositionBatch(catalog.Parts.Select(e => e.CreatePart()), null);
 6 
 7             var container = ServiceLocator.Current.GetInstance<CompositionContainer>();
 8 
 9             container.Compose(batch);
10         }

Additionally, we had to register the CompositionContainer in itself in order to be retrieved by the service locator in that piece of code.

You can find a sample that contains the MEF version of this approach in my Skydrive account under the name MefLibraryCachingSupport.zip.

Please note that this might not be the best approach to achieve this functionality, and it hasn’t been thoroughly tested; the intention of this post is to explain why this happens, and provide a possible workaround that might also serve as an example to implement the approach differently.

How to: define module-specific resource dictionaries in Prism

Guido Leandro Maliandi — Wed, 18 Jan 2012 21:09:15 +0000

Resource dictionaries are a nice way to specify styles, data templates, and similar items in WPF/Silverlight applications. In Prism modules, some times one would expect to define resource dictionaries that are specific to a certain module, as this would avoid exposing module specifics to the rest of the application. Yet, this might not be totally trivial, because resource dictionaries are usually defined in the App.xaml, and the only App.xaml that is used in most Prism applications is the one that belongs to the Shell project. I thought of a possible way to overcome this problem, which I’ll explain below.

But first, let’s examine what happens with those resource dictionaries when they are specified in the Shell’s App.xaml, and why views can consume them even if they’re defined on a separate project. Resources defined in the App.xaml become available in the Application.Resources ResourceDictionary of the current Application class (which can be accessed through the Application.Current static property.) Once they’re available there, they can be consumed from within the XAML as static resources. Since modules are loaded into the same application domain as the Shell project, views defined there can access resources as long as they can be found in the corresponding Application.Resources dictionary.

You may have noticed that some times modules also contain an App.xaml file. This file isn’t loaded when Prism modules are loaded; only one Application class is instantiated, and that’s the one in the Shell project.

So, while defining the resources in the module’s App.xaml file would make them show in the designer, they wouldn’t work when the application is ran. Going backwards a little, Application.Current.Resources can be accessed from anywhere inside the Prism application (even modules), and the ResourceDictionary class supports adding new entries! So you might see where I’m going with this…

The approach

I tried programmatically adding new entries to the Application.Current.Resources dictionary and it worked! So this leaves us with two more needs in my opinion:

A way to get the resources to add from a XAML resource dictionary file (in the module, of course.)
A comfortable way to specify that the resources in that file should be loaded.

The first one was actually simple. We can create a new instance of the ResourceDictionary class passing the file’s URI as the source. As for the second one, I thought that perhaps abstracting the whole thing with an attribute might be a good idea. So, I created an attribute named ModuleResourceAttribute, which has a constructor that accepts a string as a parameter; this string should be the location of the XAML file, e.g. “/ModuleA;component/ModuleResources/Resources.xaml”. The idea is that this attribute could be specified on a module, like this:

1 [ModuleResource("/ModuleA;component/ModuleResources/Resources.xaml")]
2     public class ModuleA : IModule
3     {
4         (...)
5     }

Then, I created a simple service to load resources into the Application.Current.Resources dictionary:

 1 public interface IResourceLoader
 2     {
 3         void LoadModuleResources(Uri resourceUri);
 4     }
 5 
 6  public class ResourceLoader : IResourceLoader
 7     {
 8         public void LoadModuleResources(Uri resourceUri)
 9         {
10             var resources = new ResourceDictionary { Source = resourceUri };
11 
12             foreach (var key in resources.Keys)
13             {
14                 Application.Current.Resources.Add(key, resources[key]);
15             }
16         }
17     }

Finally, I created a modified implementation of the ModuleInitializer so that it checks if the module has any ModuleResourceAttributes to load the necessary resources prior to module initialization:

 1 public class ModifiedModuleInitializer : IModuleInitializer
 2     {
 3         (...)
 4 
 5 
 6         public void Initialize(ModuleInfo moduleInfo)
 7         {
 8             if (moduleInfo == null) throw new ArgumentNullException("moduleInfo");
 9 
10             IModule moduleInstance = null;
11             try
12             {
13                 moduleInstance = this.CreateModule(moduleInfo);
14                 this.LoadResources(moduleInstance);
15                 moduleInstance.Initialize();
16             }
17             catch (Exception ex)
18             {
19                 this.HandleModuleInitializationError(
20                     moduleInfo,
21                     moduleInstance != null ? moduleInstance.GetType().Assembly.FullName : null,
22                     ex);
23             }
24         }
25 
26            (...)
27 
28         protected virtual void LoadResources(IModule moduleInstance)
29         {
30             var attributes = moduleInstance.GetType().GetCustomAttributes(typeof(ModuleResourceAttribute), true).Cast<ModuleResourceAttribute>();
31             if (attributes != null)
32             {
33                 foreach (var attribute in attributes)
34                 {
35                     var resourceUri = new Uri(attribute.ResourceLocation, UriKind.RelativeOrAbsolute);
36                     resourceLoader.LoadModuleResources(resourceUri);
37                 }
38             }
39         }
40     }

I also created a little sample that portrays this, which can be found in my SkyDrive account under the name ModuleSpecificResourceDictionaries.

I hope you find this handy!

Windows Azure Caching Service: How distributed and local caches work together

Jorge Rowies — Tue, 17 Jan 2012 14:12:49 +0000

Introduction

The intention of this post is to show how the distributed and local cache of the Windows Azure Caching Service work together. We are going to cover the implications of enabling the local cache feature, the interaction between the local and distributed caches, and how to prevent unexpected errors that can be caused by the in-memory nature of the local cache.

For a complete description about what the Windows Azure Caching Service is and how it can be configured, please read:
Introducing the Windows Azure Caching Service
Azure AppFabric Caching Service
Building Windows Azure Applications with the Caching Service

Implications of enabling the local cache feature

When a client enables the local cache feature, an in-memory cache is created in the same memory space where the client is running. This dramatically improves performance when storing and retrieving cache objects, but this does not come without a cost. By enabling local cache in every client, more replicas of the same data will exist, since you will have copies of the data in the original source (i.e. SQL database), in the distributed cache (cloud) and in every client’s local cache as well. Handling data replication is not a trivial matter, so deciding whether to enable local caching or not will depend on the scenario.

Interaction between the local and distributed caches

One important thing to know is how local and distributed caches interact with each other. Below you can find diagrams showing how two clients (Blue and Green) perform actions against the cache, and the consequences that each action has on the data of every cache instance.

Blue client stores key “A” in the cache:

Green client retrieves key “A” from the cache

Blue client retrieves key “A” from the cache

Blue client updates value for key “A”

Blue client removes key “A” from the cache

Green client retrieves key “A” from the cache

NOTE: for the use cases depicted in the diagrams, we are assuming that the objects stored in the caches will not expire before clients try to retrieve them.

The in-memory nature of the local cache

Given that the local cache resides in-memory, keep in mind that every change to an object after it was stored in the cache, will change the cached object as well (because the objects are the same). Clearly, this is not true with the distributed cache, because a serialized representation of the object is stored in that case.

Storing a new Movie object in the cache:

Changing the properties of the same Movie object will change the object stored in the local cache as well:

That’s it, I hope this helps!

When/Then Unit Test Naming Pattern

Geoff Cox — Mon, 16 Jan 2012 18:46:26 +0000

Giving meaningful names to unit tests is critically important to quality unit tests. Unit tests classes often contain a large set of test methods and it can be challenging to distinguish from between tests because of the small permutations of the condition, the action, or the result.

I was clued in to the When/Then naming pattern when working with Patterns & Practices at Microsoft. I’ve seen this naming pattern work well across both client and web projects containing several hundred unit tests for all kinds of classes. I’ve adopted for all my unit tests with success.

The pattern

When<ActionAndCondition>Then<ExpectedResult>.

For example, a unit test that verifies the PropertyChanged event is raised when the Name property is changed might read: “WhenNameSetToDifferentValueThenPropertyChangedRaised”.

Benefits

The When/Then naming pattern works well because it includes the action, condition, and result. By putting the key semantic information in the name of the unit test there is no longer a need for method or code comments explaining what is being tested.

The When/Then naming pattern has several other benefits.

•    It naturally focuses each unit test on verifying one result. This encourages writing atomic tests an discourages integration tests posting as unit tests.
•    It helps evaluate the purpose of each member of a class by thinking about the conditions and results. This also illuminates other unit test permutations.
•    It helps describe the test independent of the code. This helps when the test code doesn’t make the condition or result as obvious as the reader would like. Most often this is due to mocking frameworks, verifying complex data, or other aspects of the test obfuscate the test’s purpose.

Tips

Some tips to consider when applying the pattern:

•    To keep the names a little shorter, you can remove passive verbs. “WhenNameIsSetToDifferentValueThenPropertyChangedIsRaised” becomes just WhenNameSetToDifferentValueThenPropertyChangedRaised. At one point I was tempted to remove the “When” and the “Then” and separate them with an underscore, but I found that it made the test name harder to read for comprehension.
•    Use standard verbs in your test names. I use “Set” for properties, “Called” for methods, and “Raised” for events. I avoid synonyms like Updated, Recalculated, Invoked, or Fired.
•    Often a set of tests are focused on single part of your class (such as the Name property). I use #region to group test cases that are related. This helps me avoid injecting excessive class structure into my test names and makes it easy to evaluate the set of tests when working toward 100% code coverage.

Additional Examples

Here are some additional examples from my own code:

#region Name Tests

WhenNameSetThenValueSet
WhenNameSetToDifferentValueThenPropertyChangedRaised
WhenNameSetToSameValueThenPropertyChangedNotRaised
WhenNameSetToNullThenExceptionThrown
WhenNameSetToEmptyThenValueSet

#endregion

#region UpdateStatistics Tests

WhenUpdateStatisticsCalledThenTotalPriceSet
WhenUpdateStatisticsCalledThenAveragePriceSet

#endregion

Using multiple CorrelationFilter objects in a Windows Azure Service Bus subscription

ajezierski — Tue, 10 Jan 2012 20:58:50 +0000

Using filters in Windows Azure Service Bus subscriptions is very useful when it comes to message categorization. When setting up a subscription, you can specify a Filter object that will be responsible of allowing messages that match a specified criteria. In this post I will focus on how we can set multiple CorrelationFilter objects for a Service Bus subscription.

Correlation filters help to establish a call-response type of relationship between a sender and a receiver through the use of the CorrelationId property of the BrokeredMessage class. Typically, the sender might set the CorrelationId property of the brokered message to some identifier. This same identifier can be used in a CorrelationFilter object associated to that particular sender when creating a subscription for the response topic.

    var id = Guid.NewGuid();
    var filter = new CorrelationFilter(id.ToString());
    namespaceClient.CreateSubscription(description, filter);

The receiver, after getting the message, will prepare a new response, setting the CorrelationId property equal to the one it received in the message it downloaded, and will post the response to a topic that will be shared by multiple sender entities. Each sender will always receive the expected response through the associated CorrelationFilter (which delivers the message to the subscription only if the CorrelationId property of the brokered message matches the id expression in the filter. Tip: consider the use of CorrelationFilter instead of SqlFilter when it comes to equality comparisons. SqlFilter has an extra overhead when evaluating the criteria expression.

Consider the following scenario:

We have n senders posting messages to a topic, allowing for m subscriptions.
We have m receivers subscribed to the sender topic, posting reply messages back to a shared reply topic.
A sender may want to make multiple requests and expect the respective replies to each request.
Each reply message may be treated differently by the sender.

The question is, how can a sender keep track of the requests it makes, and how can it receive the expected reply message without the knowledge of the other senders?

The answer is as simple as… “let the sender manage a collection of correlation filters! “ We can achieve this through the use of Rules. A rule allows a subscription to execute an action on messages that match a rule’s filtering criteria. Rules can be managed through the SubscriptionClient class. Let’s take a look at the code.

Through the MessagingFactory we create a SubscriptionClient. We then call the AddRule method, creating a new RuleDescription object. The RuleDescription will contain the name or identifier of that rule, and the corresponding associated CorrelationFilter. Using the RuleAction property escapes the scope of this post, but you can read about it here.

    // Create new rule containing a new CorrelationFilter.
    var subscriptionClient = this.messagingFactory.CreateSubscriptionClient(Constants.ReplyTopic, this.senderName);

    var rule = new RuleDescription
    {
       Filter = new Microsoft.ServiceBus.Messaging.CorrelationFilter(id.ToString()),
       Name = id.ToString(),
    };

    subscriptionClient.AddRule(rule);

When we are done with rule, we can call the RemoveRule method of the SubscriptionClientClass.

Note that we can use Windows Azure Service Bus for a wide variety of scenarios, and solve similar problems in many different ways. Today we went down the path of subscriptions and correlation filters.

Check out these other posts if you want more information on Windows Azure Service Bus Brokered Messaging

http://convective.wordpress.com/2011/09/21/windows-azure-appfabric-service-bus-brokered-messaging/

http://social.technet.microsoft.com/wiki/contents/articles/best-practices-for-leveraging-windows-azure-service-bus-brokered-messaging.aspx

http://msdn.microsoft.com/en-us/library/windowsazure/hh367512.aspx

Happy learning!

High memory consumption in WaWorkerHost.exe

Jorge Rowies — Mon, 09 Jan 2012 21:08:05 +0000

When the memory usage of the WaWorkerHost.exe process starts going up without apparent reason, and you are using Tasks in your worker role, it might be the time to check for unhandled exceptions and start handling them properly.

Throwing exceptions from Tasks in a worker role and NOT properly handling them:

    public class WorkerRole : RoleEntryPoint
    {
        public override void Run()
        {
            while (true)
            {
                Task.Factory.StartNew(() => { throw new NotImplementedException(); });
                Thread.Sleep(100);
            }
        }
    }

Might cause this memory consumption in the WaWorkerHost.exe process:

NOTE: WaWorkerHost.exe is the process in charge of hosting your worker roles when running in the emulator.

Below you can find one way to handle exceptions that are thrown in Tasks.

    public class WorkerRole : RoleEntryPoint
    {
        public override void Run()
        {
            while (true)
            {
                Task.Factory.StartNew(
                    () =>
                    {
                        throw new NotImplementedException();
                    })
                    .ContinueWith((t) =>
                    {
                        Trace.WriteLine(string.Format("Exception in Worker Role: {0}",
                            t.Exception.InnerException.ToString()));
                    },
                    TaskContinuationOptions.OnlyOnFaulted);

                Thread.Sleep(100);
            }
        }
    }