During the following post I'm going to explain a design pattern widely used during software development processes and how it fits into the .NET ecosystem. This pattern would probably fits into the structural patterns group and it's mainly used to decouple components, so abstractions and concrete implementations can vary independently.

Using the provider pattern in .NET (and most object oriented languages) is pretty easy. We need the following artifacts:

• A provider definition, used as a contract that specifies what it should do
• One or multiple provider implementations of the declared contract
• A consumer willing to make use of the provider and it's implementations

Imaging the following real life scenario: There is a basic definition of what a car should do (provider definition) and what is considered a car: it must have 4 wheels, an engine, steering wheel, etc.. in the market you are able to find lot of implementations following the actual definition of a car (implementations of the provider), and we, as consumers, can make use of the knowledge and methods defined in the provider contract to change the implementation we use without affecting our behavior (we are able to switch cars and use the common definition of it, as a car, to drive any of the implementations).

So know, imagine it in the context of software development. We have an interface that defines a set of properties and methods that our provider must implement; we then have one or multiple implementations of that interface available; and of course, any consuming application can use the interface to switch between implementations without being affected. Have a look to the following diagram:

This is pretty awesome and practical when we are willing to create componentized and decoupled applications. We just use interfaces. This pattern has been widely used in the new ASP.NET 2.0 to create the application services provider infrastructure. For example, the MembershipProvider can be defined either as SqlMembershipProvider or as a custom OracleMembershipProvider; they both provide the same functionality but with different behavior (one uses SQL Server as repository while the other is using Oracle databases)

This pattern itself, IMHO, can dramatically increase the quality of your architecture because of the modularity and simplicity it provides.

One of the hidden treasures of .NET is the existence of a Provider Model Framework that allows you to create custom Providers for anything (not only extensions of ASP.NET Providers, but any kind of .NET application or service)

Using .NET Framework 2.0 Provider Model

So let's start writting some code. To create a provider we first have to create a public abstract class that defines our contract. This class must implement the System.Configuration.ProviderBase abstract class and it should contain the definition of methods and properties used as the "contract" of our provider.

1 public abstract class ImageProvider : ProviderBase
2 {
3    public abstract bool CanSaveImages { get; }
4    public abstract Image GetImage(int id);
5    public abstract void SaveImage(Image image);
6 }

We then need to add the actual implementations of the provider. In this case, we are going to add an image provider for the file system and an extra one for SQL Server.

 1 public class FileSystemImageProvider : ImageProvider
 2 {
 3     public override bool CanSaveImages
 4     {
 5         get
 6         {
 7             return true; // As we allow to save images
 8         }
 9     }
10 
11     public override Image GetImage(int id)
12     {
13         // Some witty code to get the image from a folder in the FileSystem
14         return null;
15     }
16 
17     public override void SaveImage(System.Drawing.Image image)
18     {
19         // Some witty code to save the image to a folder in the FileSystem
20     }
21 }
22 
23 
24 public class SqlImageProvider : ImageProvider
25 {
26     public override bool CanSaveImages
27     {
28         get
29         {
30             return true; // As we allow to save images
31         }
32     }
33 
34     public override Image GetImage(int id)
35     {
36         // Some witty code to get the image from a folder in the FileSystem
37         return null; ;
38     }
39 
40     public override void SaveImage(System.Drawing.Image image)
41     {
42         // Some witty code to save the image to a folder in the FileSystem
43     }
44 }

And finally, we need to create the service that will use the ImageProvider. It's is coupled to the contract definition of our provider and not to it's implementations, so it knows what to ask for but no actually how or where will it be done. The service just initializes the provider using the LoadProvider() method (it should read the provider from the config file; have in mind that here it's hardcoded for instructional purposes and you only need to change the LoadProvider method to achieve that goal)

 1 public class ImageService
 2 {
 3     private ImageProvider _provider;
 4 
 5     public ImageProvider Provider
 6     {
 7         get
 8         {
 9             return _provider;
10         }
11     }
12 
13     public ImageService()
14     {
15         LoadProvider();
16     }
17 
18     public void LoadProvider()
19     {
20         ProviderSettings ps = new ProviderSettings("FileSystemImageProvider", "FileSystemImageProvider_Type_Assembly");
21         _provider = ProvidersHelper.InstantiateProvider(ps, typeof(FileSystemImageProvider)) as ImageProvider;
22     }
23 
24     public Image GetImage(int id)
25     {
26         return _provider.GetImage(id);
27     }
28 
29     public void SaveImage(Image image)
30     {
31         _provider.SaveImage(image);
32     }
33 }

The main caveat of using the .NET Provider Model is that you must reference the System.Web assembly in, probably, non-web projects. This is needed in order to access the ProvidersHelper class used to instantiate the provider collection. And it also forces the application to use the System.Configuration namespace and classes to read the provider configuration located in the web.config or app.config files.

You'll have to deal with the types and assembly names where those types are defined to create the ProviderSettings instance needed by the ProvidersHelper.InstantiateProvider method. It's maybe not recommended to use all this "web" references in a desktop or service context; so there's a clean and elegant alternative for the OO purists :)

The pure OO implementation

So, we need to get rid of the System.Web reference and make the provider pattern work without using the .NET Framework 2.0 model. The first thing we need to do is to refactor provider's abstract class to an interface (or leave it as a class, it's up to you, but remove the ProviderBase inheritance and any reference to the System.Configuration namespace) and change the concrete providers implementations to make them use the newly created interface. The class diagram should look similar to:

First, we should create the following code for the provider contract:

1 public interface IImageProvider
2 {
3     bool CanSaveImages { get; }
4     Image GetImage(int id);
5     void SaveImage(Image image);
6 }

And of course change the signature of the concrete provider implementations for FileSystemImageProvider and SqlImageProvider so they use the new contract:

 1 public class FileSystemImageProvider : IImageProvider
 2 {
 3    // Implementation of the provider code, only signature of the class changed
 4 }
 5 
 6 
 7 public class SqlSystemImageProvider : IImageProvider
 8 {
 9    // Implementation of the provider code, only signature of the class changed
10 }

The ImageService still almost the same, we only need to change LoadProvider's code so it creates an instance of the desired concrete implementation without using the ProvidersHelper class. Something like this may work perfectly:

1 public void LoadProvider()
2 {
3     _provider = Activator.CreateInstance(typeof(FileSystemImageProvider)) as IImageProvider;
4 }

Any conclusion?

As you can see, the approach it's quite similar for both methods and it's really simple to introduce it in most of actual software projects and architectures. It provides ease of installation, highly decoupled systems and modularity both in development and deployment.

There's no excuse to avoid this pattern, as far as it's possible and pragmatic to use it in the context of your architecture :)

Hope this helps anyone.

It was time to get a Commerce Server version up to nowadays technologies. This was my first thought a while ago when listening to Ryan Donovan, Product Unit Manager for Commerce Server 2007.

In the past I had the chance (or bad luck) to deal with Commerce Server, and I was missing a lot of features. In last version, the migrated most of the code and content to ASP.NET but it still required all the classic COM componentes used in previous versions. This has completely changed. Finally.

The actual model is completely developed over ASP.NET 2.0 and on top of it you can find the object model (catalogs, orders, etc...) presented by Commerce Server... there is a new extensibility layer over all those components exposed with web services and a new .NET API that supports all the managing and updating content options.

The most interesting part seems to be the integration of web controls inside ASP.NET that allow to develop e-commerce site dragging and dropping ASP.NET 2.0 templated controls. This was impossible until now. There are more new features like virtual catalogs, integration with Biztalk 2006, support for Membership, Themes and Masterpages, integration with Sharepoint 2007 and support for Active Directory Federation Services (more to come about this)

The Agile note of this presentation was: “The included Starter Site includes a complete set of unit tests“ .. Than you. Really.

I've been some time playing and testing with Atlas. I'm pretty excited to get it real and ScottGu has finally announced that Atlas will hit 1.0 before the end of this year. It would go through the typical beta, rc and rtm path, but it will be available as an extension for ASP.NET 2.0.

Atlas is going to be divided into three modules:

• Microsoft AJAX Library for the Client Library
• Microsoft AJAX Extensions for ASP.NET 2.0 for the Server Library
• Microsoft AJAX Control Toolkit for the Control Library

It seems that pretty cool name goes wasted (as it happened to Indigo, Avalon, Whidbey, etc...) again, but the important thing is that we are getting support for AJAX in our ASP.NET 2.0 applications.

Get up to date. Read more Atlas related at:

• Atlas - http://atlas.asp.net
• Atlas Control Toolkit - http://www.codeplex.com/Release/ProjectReleases.as...
• Atlas Control Toolkit Samples - http://atlas.asp.net/default.aspx?tabid=47&subtabi...
• Scott Guthrie - http://weblogs.asp.net/scottgu
• Nikhil Khotari - http://www.nikhilk.com
• Shawn Burke - http://blogs.msdn.com/sburke
• Bertrand Le Roy - http://weblogs.asp.net/bleroy

I recently installed Windows Vista pre-RC1 (5536) and it's going perfectly with it; I installed Visual Studio 2005 Team Suite also and I am using the laptop to perform my daily work.

Everything is running fine, but I had some problems trying to debug ASP.NET applications. The problem is that IE7 and Vista are really focused on security, so there's a separate process and user running IE with the least possible privileges. This ain't good for my debugger, because attaching a process is something that could easily be considered harmful.

So, how did I managed to get it to work?

Simple. The ASP.NET applications run on they local server provided by Visual Studio 2005. That is considered an Intranet. By default, Intranet permissions are not configured under IE7 in Vista, so the first time you try to access you http://localhost web server it will ask you to configure it. Do so.

Now you are able to run your ASP.NET developed web application on your own machine and see the results. But you still without debugging.

The solution is simpler than the previous one. To validate that you allow to attach a process to the site that runs the webs you're developing, add the site "localhost" to the Trusted Sites list of IE7, so it will not complaint about it. The next time you start a site included in the trusted list IE will open a new window for it because different trust levels can't coexist in the same process. There's no option to use tabbed browsing, just new windows.

That's all. Happy debugging in Windows Vista.

Last week I was talking with my brother about a presentation I'm preparing to show AJAX and Atlas at my company. He was also preparing one at his company and asked me a couple of things. The first thing I said was "well, I guess it's better to wait a bit til Monday or Tuesday so we can get the new Atlas CTP that will surely be released" ... I knew nothing about this release, but it was more than obvious that there was going a release coming up at MIX'06

So, if we had any doubt here is the official page for the Atlas March CTP with a bunch of new features and fixes that can be found here. Within all the new stuff we have: a better designed and informative web site, better documentation and learning resources and some videos from MIX'06 where they show the new features.

One more interesting thing relating to this release... a MashUp contest is running (try this definition of MashUp if you don't know what it is) within the Atlas team, so go and create your killing Atlas app. Check the contest here.

I posted a couple of days ago about my problems debugging HTML source code when working with AJAX and also how I planned to solved it with Internet Explorer Developer Toolbar. It worked, it allowed me to inspect the actual DOM and see how it changed my original source... but it was too slow to debug it that way.

Fortunately, my brother posted a comment pointing me to this post by Rumen Stankov where he shows a trick to view and save the actual source in Internet Explorer. Just paste the following in your address bar:

  javascript:'<XMP>' + window.document.body.outerHTML + '</XMP>'

Hope you find it as useful as I do. Why doesn't the Developer Toolbar includes something like this feature?

This is pretty old news, but it seemed pretty useful to me today. Related to a couple of AJAX problems where I couldn't inspect the current CSS and HTML object stacks, I needed a tool that allow me to inspect them on the fly.

So, I just remembered about the Internet Explorer Developer Toolbar Beta 2, installed it and started to see how my page change with every callback.

I just took this exam today and it seemed to have a pretty good level. The exam was divided in three section of 30 questions each. Once you finish a section you can't go back and change your answers, but you can go back to add comments to them.

The first section was specific to web applications and it has a bunch of question with mobile pages, mobile devices, web forms and web controls as the main topics. The second part of the exam looked the hardest one, it was related to framework and types with security attributes, xml serialization attributes, class design and generics in its topics. The third part, the one I was really scared of, was the architecture one and it was really easy to pass, lot of logical questions about designing solutions and best practices.

There is one thing I still have in mind, that really impressed me positively. I got some questions talking about unit testing, code coverage and integration tests ... :-D

As with all the beta exams, I'll have to wait to get my results a couple of weeks. While I wait, I'll take more exams.... Next stop: 71-552 Upgrade from MCAD to MCPD Windows Developer; next Monday morning.

Being on the rush is not easy...

If you have an idea of a cool (or not) web application you have to target it to the web2.0 market and it will success. Sure. But. How you make anything look like web2.0? Easy. add over-sized fonts, the word "social" in your description, a white background and tags clouds to your site!!! You're done. Get ready to sell you site to one of the bigs... ;-P

Read the full article, it's funny and instructional: http://mentalized.net/journal/2005/10/10/building_your_very_own_web20_layout/

Have you ever though on how to make any HTML control non-focusable? Yes, thinking about how to not allow it to get focus when using the UI... I've digged a bit about it and found that there's no HTML attribute to provide this functionallity and I came with this idea that solved my problem.

Browsers use the TabIndex property to determine which control is the next to get the focus. It's a zero-based count. So what if you put any negative number as the value for the TabIndex property??? Easy. It works. That control won't get focused while tabbing in your form. So this control is now non-focusable.

Hope you find it useful.