Reducing Complexity

Use before Reuse

2010-03-03T07:47:00.001-08:00

I have been doing a lot of software design work in past months. As you know design is not easy. It’s almost always about making (hard) decisions. It’s about considering alternatives and weighting options. In that sense, I’ve also tried to learn more and expand my knowledge about software architecture and software design. As the main source of usable knowledge, I find the “Domain-driven design” book. You’ve probably heard of the Repositories, Aggregates, Value object etc. But, what I value the most in this book is the part called “Strategic design”. It’s the part that talks about Bounded Contexts, Context Maps, Core domain etc. Really, this is the most valuable part of the book. Eric Evans, himself, in his What I’ve learned about DDD since the book talk kind of admits that putting that part at the end of the book was a mistake. If you do software architecture and design I strongly advise you to explore that part of the book. However there is one advice-practice, that changed the my thinking from ground up. I have read this article by Kevlin Henney. The title of the article is “Simplicity Before Generality, Use Before Reuse”. The article is about how to value concrete and specific solutions over the more general solutions. Business people mostly have problems that are specific to them and thus need specific solutions. Software people, on the other hand, like to generalize. They (we) like to see abstractions everywhere and try to come up with general solutions that can solve all the problems. Of course, this will not happen. This usually end by making things more complex without any benefit. Go and read this article.

How to use Custom RoleProvider in WCF?

2010-02-16T11:03:00.001-08:00

First thing is to add reference to the System.Web.dll assembly to your WCF project. Then create a class which inherits from RoleProvider. You’ll also need to add the System.Web.Security namespace. Then you can use the CTRL+dot trick so that VS generates all the methods for you. You’ll end up with something like this:

public class MyRoleProvider : RoleProvider

    public override void AddUsersToRoles(string[] usernames, string[] roleNames)

        throw new NotImplementedException();

    public override string ApplicationName

get

            throw new NotImplementedException();

set

            throw new NotImplementedException();

    public override void CreateRole(string roleName)

        throw new NotImplementedException();

    public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)

        throw new NotImplementedException();

    public override string[] FindUsersInRole(string roleName, string usernameToMatch)

        throw new NotImplementedException();

    public override string[] GetAllRoles()

        throw new NotImplementedException();

    public override string[] GetRolesForUser(string username)

        throw new NotImplementedException();

    public override string[] GetUsersInRole(string roleName)

        throw new NotImplementedException();

    public override bool IsUserInRole(string username, string roleName)

        throw new NotImplementedException();

    public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames)

        throw new NotImplementedException();

    public override bool RoleExists(string roleName)

        throw new NotImplementedException();

Now, you’ll need to provide actual implementation for all of these methods. That’s up to you.

Next, you need to configure your config file. Add following to the system.web section of your configuration file:

<system.web>

    <roleManager enabled ="true">

        <providers>

            <add  name="MyRoleProvider" type="ReducingComplexity.MyRoleProvider, ReducingComplexityRoleProvider"/>

        </providers>

    </roleManager>

</system.web>

Now you’ll need to link this role provider to your services services. You will use serviceBehavior for this. For example, if you have service behavior defined like this:

<behaviors>

    <serviceBehaviors>

        <behavior name="MyServis.MyStandardBehavior">

            <serviceAuthorization roleProviderName="MyRoleProvider" principalPermissionMode="UseAspNetRoles"></serviceAuthorization>

        </behavior>

    </serviceBehaviors>

</behaviors>

Using the <serviceAuthorization>, I set roleProviderName with the name of my role provider as defined under <roleManager> node. Also, principalPermissionMode need to be set to UseAspNetRoles. That’s pretty much it. It’s that simple.

Now it’s possible to use both declarative security framework:

[PrincipalPermission(SecurityAction.Demand,Role = "Customer")]

public List<Order> GetOrders(int customerId)

or for example Thread.CurrentPrincipal.IsInRole() method.

public List<Order> GetOrders(int customerId)

    if (Thread.CurrentPrincipal.IsInRole("Customer"))

        // get customer orders

    else

        // permission denied

WCF rocks!!!

Still, there is something I really don’t like. It is the fact that RoleProvider is considered to belong to ASP.NET(hence the need to add reference to System.Web.dll assembly). This is kind of unnatural, and I would like to see the role providers moved to some other assembly, for example System.Security.dll.

WCF and AOP with Castle.DynamicProxy

2010-02-15T07:10:00.001-08:00

Managing logging and exception handling in WCF applications can be very time-consuming. Cross-cutting concerns can become a great burden and generate a lot of work for us. Today, I played a little bit with AOP and Castle Dynamic Proxy (DP) library. If you’re not familiar with AOP please take a look at this.

Before I even started with DP, I also considered PostSharp, but eventually I decided to go with DP. Reason: I just don’t like things integrated into VS and doing stuff I cannot fully control. It can be that this is not a legitimate reason, but still:).

I started by adding references to Castle.Core.dll and Castle.DynamicProxy2.dll files. Then I defined my Logging Aspect class

public class LoggingAspect : IInterceptor
{
    #region IInterceptor Members

    public void Intercept(IInvocation invocation)
    {
        Debug.WriteLine(string.Format("The user {0} is calling method {1}.", OperationContext.Current.ServiceSecurityContext.PrimaryIdentity.Name, invocation.Method.Name));
        Debug.WriteLine("Parameters are : ");
        foreach (object argument in invocation.Arguments)
        {
            Debug.WriteLine("Parameter value : " + Convert.ToString(argument));
        }
        invocation.Proceed();
        Debug.WriteLine(string.Format("The calling is complete!"));
    }

    #endregion
}

This code is pretty straightforward. By implementing IInterceptor interface, I print out username of the calling user, the method called, and parameter values. You’ll probably want to write these info into a database or a file in your project. However, this will stands good as an example. Then, to create a proxy for a type:

ProxyGenerator pg = new ProxyGenerator();
var loggingAspect = new LoggingAspect();
var proxy = pg.CreateClassProxy(typeof(MyType), loggingAspect);

That is all I need to do regarding DP itself. Now, I need to integrate this into WCF. Luckily, WCF is very extensible framework. First, I’ll implement IInstanceProvider interface, so that I can control object instances creation. The interface is rather simple, consisting of three methods.

public class MyInstanceProvider : IInstanceProvider
{
    public Type Type { get; private set; }
    public MyInstanceProvider(Type type)
    {
        this.Type = type;
    }

    #region IInstanceProvider Members

    public object GetInstance(System.ServiceModel.InstanceContext instanceContext, System.ServiceModel.Channels.Message message)
    {
        ProxyGenerator pg = new ProxyGenerator();
        var loggingAspect = new LoggingAspect();
        var proxy = pg.CreateClassProxy(this.Type, loggingAspect);
        return proxy;
    }

    public object GetInstance(System.ServiceModel.InstanceContext instanceContext)
    {
        return GetInstance(instanceContext, null);
    }
    public void ReleaseInstance(System.ServiceModel.InstanceContext instanceContext, object instance)
    {
        if (instance is IDisposable)
            ((IDisposable)instance).Dispose();
    }

    #endregion
}

Note that I’m using CreateClassProxy method of ProxyGenerator to create proxies. This requires that methods we want to intercept need to be marked as virtual. Now that I have my IInstanceProvider implemented, I need to hook it up to a service. There are several options for this, but I like using attributes for this. I want to be able to mark my service implementation with some attribute so that all methods on that are intercepted in the same way. To do this I’ll need an attribute that implements IServiceBehavior interface.

public class MyAspectsAttribute : Attribute, IServiceBehavior
{

    #region IServiceBehavior Members

    public void AddBindingParameters(ServiceDescription serviceDescription, System.ServiceModel.ServiceHostBase serviceHostBase, System.Collections.ObjectModel.Collection<ServiceEndpoint> endpoints, System.ServiceModel.Channels.BindingParameterCollection bindingParameters)
    {
    }

    public void ApplyDispatchBehavior(ServiceDescription serviceDescription,
        System.ServiceModel.ServiceHostBase serviceHostBase)
    {
        foreach (var dispatcher in serviceHostBase.ChannelDispatchers)
        {
            var cd = dispatcher as ChannelDispatcher;

            foreach (var endpoint in cd.Endpoints)
            {
                endpoint.DispatchRuntime.InstanceProvider = new MyInstanceProvider(serviceDescription.ServiceType);
            }
        }
    }

    public void Validate(ServiceDescription serviceDescription, System.ServiceModel.ServiceHostBase serviceHostBase)
    {

    }
    #endregion
}

The most important thing here is the ApplyDispatchBehavior method where I set up the instance provider for each endpoint. Next, the only thing left is to mark my service with MyAspects attribute.

[MyAspects]
public class MyGreatService : IMyGreatService 
{
    public virtual string SayHello()
    {
        return "Hello";
    }
}

This way, SayHello() method (and all others marked as virtual) will be intercepted by my LoggingAspect class thus enabling me to centralize my logging code.

Convention over Configuration – the Microsoft way!

2010-02-08T11:10:00.001-08:00

I like the concept of Convention over Configuration. It really makes sense. I only need to change parts of the configuration that are specific for my case. Here’s the Wikipedia definition of the concept:

“Convention over Configuration (also known as Coding by convention) is a software design paradigm which seeks to decrease the number of decisions that developers need to make, gaining simplicity, but not necessarily losing flexibility.”

It looks like that at Microsoft, they also liked the Convention over Configuration concept. Take for example the resource files in Visual Studio. Every form has it’s its’s resource file named in format [FormName].resx. This is great, but how do I change the .resx file for a form? I only want to change .resx file name, not the form name. I’m missing the Rename command on the context menu:

No rename here. OK, let’s try by clicking Properties on the Form1.resx file, and changing the name there.

The filename field is read-only. So there is no way to change the file whatsoever. It seems that Microsoft didn’t quite get the bolded and colored part of the Convention over Configuration definition:

“Convention over Configuration (also known as Coding by convention) is a software design paradigm which seeks to decrease the number of decisions that developers need to make, gaining simplicity, but not necessarily losing flexibility.”

I don’t have flexibility to change the name of the .resx file for a form.

Why am I telling all of this?

If you have ever written something like this:

public class MyForm<T>: Form 
{
     ...
}

and tried to use resources on your Form, you’ll get whole kind of interesting problems. But there is not much you can do about it. Thanks for reading!

I’m having some hard time with Mono.Cecil

2010-02-07T15:32:00.001-08:00

Mono.Cecil is great library, no doubt about that. But there are some things that are bugging me.

No documentation

This one is serious. A framework without documentation is very hard to use. Usually time is being wasted just to figure out how to do some of the very simple things.

API is hard to use

Generally, the API is OK, but it requires a lot of writing. Also, it’s easy to get lost in all of the MemberReferences, MethodReferences, MethodDefinitions, FieldReferences, FieldDefinitions, TypeReferences stuff. Writing IL is not easy at all. Especially when things get a bit complicated. Wouldn’t it be nice if Mono.Cecil had a interpreter/compiler in it. So, we could write C# code that would be translated to IL. Add to that a nice fluent interface:

  AssemblyDefinition assembly = AssemblyFactory.GetAssembly("SomeAssembly.dll");

            assembly.WithType("MyClass")
                    .WithMethod("SomeMethod")
                    .AppendCode(@"
                                    int x = 5; 
                                    Console.WriteLine(x); 
                                ");

I guess that I’m asking for too much with the interpreter/complier stuff, but a Mono.Cecil fluent interface would be very convenient.

Testability – unit testing

How do you test code that works with Mono.Cecil? Here is my Mono.Cecil development cycle:

Write code that uses Mono.Cecil
Write the dummy assembly to the disk
Open the assembly in the Reflector to see if everything is fine.

As you can see there is no test automation here whatsoever. The whole process is manual and very time consuming.

As I said, Mono.Cecil is great but more documentation and an Fluent Interface would make it much more better. If you have any advices on how to overcome these difficulties please let me know.

Exploring the MVP Pattern

2010-02-06T16:54:00.001-08:00

Windows Forms are still number one choice when it comes to development for Windows platform. Windows Forms are easy and proven. In most cases you use things out-of-the-box. If you need something special, you have the ability to make custom controls work the way you want. For most enterprise applications I would dare to call Windows Forms near to perfect. So what is this post about then? Imagine that you’re building a typical enterprise application with layered architecture. You’ve organized your layers perfectly, looking like this:

Next imagine that you’re done with developing your data and business layers. You’re happy since you have a nice, clean and loosely coupled design so far. Everything seems perfect as it can be. The next step is to work on your presentation layer. You are all excided! Of course, you choose to use Windows Forms for that. Shortly, after starting the development of presentation layer, you start to feel weird. Your feeling of nice, clean codebase starts to disappear. You start to see your BLL classes mixed in various event handlers. A lot of (object sender, EventArgs e) stuff makes you feel sad. You see code like txtName.Text and listViewOrders.Items all over the place. Little by little, it gets harder to gain control of the complexity.

Reason behind this post

First off, if you already have experience in using MVP pattern in Windows Forms, then it may be possible that you will not benefit that much from reading this post.

There are a lot of sources about implementation of the MVP pattern in Windows Forms applications. However, while exploring the pattern on my own, I didn’t find a lot of applications with full source code provided. Also, example applications were very simple, far from what can be seen in real-world applications. This made my understanding of MVP pattern harder. In that sense, I have set following goals for this post:

Build an working application by using MVP pattern.
Provide full source for it.
The application needs to be more complex than a simple “Hello World” example
Explain benefits of using MVP in Windows Forms applications

The problem

My application consists of a single form. I’ll call the form Money Transfer Form. The form is used to initiate money transfer from one account to another. Each account has an ID and the name of the account owner. An account can be either of type Personal or Company. The actual transfer can be either Standard, International, Extended (no idea what that means). When transferring money, one needs to provide amount which needs to be of specific currency. Here are the other requirements/rules:

When transfer type is Standard the amount that can be transferred is limited to 500
When transfer type is International the amount cannot be lower then 200, and the currency needs to be in dollars. However, if dollar exchange rate at the moment of transfer is below 1.3, then the minimum amount that’s allowed needs to be 700. User of application needs to be notified when this happens. Also, in such case, another currency can be used for transfer.
When transfer type is Extended and both accounts are Company, an additional description of the transfer needs to be specified. Normally, users cannot enter any kind of description unless these conditions are not satisfied. The description cannot exceed 20 characters. If it does, the user will be asked a if he wants to reset the description (clear it). Also, as long as description is larger then 20 characters, this will be indicated with different color in UI.
When user enters account number, the name of the account owner and account type has to be displayed on the form.
Before actual money transfer is initiated, application needs to ask the user to confirm such action. Also, when transfer has been done, the user needs to be informed.

Note that these rules really don’t make any sense, but can provide us with the complexity that often is found in real-world applications.

Domain design

Here is my domain model:

The core domain model is very simple. To most interesting part is MoneyTransfer class.

Validation

Since I have a lot of business rules, I have to think about validation. There has been a lot of discussions about validation in domain model. There are generally 2 different approaches

1. Let the entity validate itself by using some kind of IsValid() method.
2. Use external services to perform validation on entities.

The first method is fine, but lacks some flexibility. The main argument against it is that the same entity can be valid in one context and not valid in some other context. Personally, I prefer to keep my validation away from entities. Validation services can also be reused. This way, in one context a one set of rules can be used, while in another context a different set of rules can be used. There are different approaches to implementing the validation services, for example introducing IValidator<T> interface, but I will not use that approach just to keep the things simpler. Here is my rule interface:

    public class ValidationResult
    {
        public string Message { get; set; }
        public bool IsValid { get; set; }
    }
    public interface IMoneyTransferRule
    {
        ValidationResult Validate(MoneyTransfer moneyTransfer);
    }

The interface is very simple since we only have Validate method on it. Every rule must implement this interface. I’ll show some rules implementing IMoneyTransferRule interface:

“When transfer type is Standard the amount that can be transferred is limited to 500”

public class StandardLimitRule : IMoneyTransferRule
{
    #region IMoneyTransferRule Members

    public ValidationResult Validate(MoneyTransfer moneyTransfer)
    {
        if (moneyTransfer.Type == TransferType.Standard)
        {
            if (moneyTransfer.Amount > 500)
                return new ValidationResult()
                           {
                               IsValid = false,
                               Message = "When transfer type is 'Standard', amount is limited to 500."
                           };
        }
        return new ValidationResult {IsValid = true};
    }

    #endregion
}
“When transfer type is Extended and both accounts are Company, an additional description of the transfer needs to be specified. Normally, users cannot enter any kind of description unless these conditions are not satisfied. The description cannot exceed 20 characters.”

public class ExtendedTransferRule : IMoneyTransferRule
{
    #region IMoneyTransferRule Members

    public ValidationResult Validate(MoneyTransfer moneyTransfer)
    {
        if (moneyTransfer.Type == TransferType.Extended)
        {
            if (moneyTransfer.From.Type == AccountType.Company && moneyTransfer.To.Type == AccountType.Company)
            {
                if (string.IsNullOrEmpty(moneyTransfer.Description) || moneyTransfer.Description.Length > 20)
                {
                    return new ValidationResult
                               {
                                   IsValid = false,
                                   Message = "Extended Company-To-Company transfers need to have description. The description needs to be below 20 characters."
                               };
                }
            }
        }
        return new ValidationResult { IsValid = true };
    }

    #endregion
}

This was my validation strategy. Now, I’ll go to repositories.

Repositories

There are two repositories in my application: ICurrencyRepository and IAccountRepository. I’ll provide two in-memory implementations of both.

AccountRepository

 public class AccountRepository : IAccountRepository
    {
        public List<Account> _accounts = new List<Account>(); 
        public AccountRepository()
        {
            _accounts.Add(new Account { ID = "1", Name = "Account 1", Type = AccountType.Personal  });
            _accounts.Add(new Account { ID = "2", Name = "Account 2", Type = AccountType.Company });
            _accounts.Add(new Account { ID = "3", Name = "Account 3", Type = AccountType.Personal });
            _accounts.Add(new Account { ID = "4", Name = "Account 4", Type = AccountType.Company });
            _accounts.Add(new Account { ID = "5", Name = "Account 5", Type = AccountType.Personal });
            _accounts.Add(new Account { ID = "6", Name = "Account 6", Type = AccountType.Company  });
            _accounts.Add(new Account { ID = "7", Name = "Account 7", Type = AccountType.Company  });
            _accounts.Add(new Account { ID = "8", Name = "Account 8", Type = AccountType.Company  });
            _accounts.Add(new Account { ID = "9", Name = "Account 9", Type = AccountType.Personal });
            _accounts.Add(new Account { ID = "10", Name = "Account 10", Type = AccountType.Personal });
        }
        #region IAccountRepository Members

        public Account Load(string ID)
        {
            return _accounts.Where(m => m.ID == ID).FirstOrDefault();
        }
        public void Withdraw(string ID, double amount)
        {
            // we don't actually do anything here
        }
        public void Deposit (string id, double amount)
        {
            // we don't actually do anything here
        }
        #endregion
    }

CurrencyRepository

  public class CurrencyRepository : ICurrencyRepository
    {
        private List<Currency> _currencies = new List<Currency>(); 
        public CurrencyRepository()
        {
            _currencies.Add(new Currency { ID = "1", Name = "USD", Country = "US", ExchangeRate = 1.6 });
            _currencies.Add(new Currency { ID = "2", Name = "GBP", Country = "United Kingdom", ExchangeRate = 1.0 });
            _currencies.Add(new Currency { ID = "3", Name = "EUR", Country = "EU", ExchangeRate = 1.95 });
        }

        public Currency Load(string id)
        {
            return _currencies.Where(c => c.ID == id).FirstOrDefault(); 
        }

        public List<Currency> GetAll()
        {
            return _currencies.ToList(); 
        }
    }

Another thing worth mentioning is TransferFailedException class:

public class TransferFailedException : Exception 
{
    public List<ValidationResult> FailedValidations { get; set; } 
    public TransferFailedException(ValidationResult[] failedValidations)
    {
        this.FailedValidations = new List<ValidationResult>(); 
        this.FailedValidations.AddRange(failedValidations); 
    }
}

MVP Pattern

MVP stands for Model-View-Presenter. The relationships between M and V and P are:

Controller is mediating between Model and View. Unlike in MVC here we don’t have direct connection between the Model and the View. The Presenter is responsible for updating both the Model and the View. This variant of MVP is called Passive View, since View acting is kind of dumb. The whole process goes like this:

Events are received on View, the View passes them to the Presenter.
Presenter decides how and if the Model needs to be updated.
Presenter initiates any needed changes on the View.

In this approach View is very simplified and worries only about the very presentation. There are no decisions being made in the View. The Presenter actually controls the logic flow. This is how Passive View variant of MVP works. There are also two other variants of MVP: Presentation Model and Supervising Controller. I will not talk about them now. This picture of Passive View may be more expressive:

That was theory. Here’s the practice:

Here it is how my form looks like:

First, I’ll abstract my frmMoneyTransfer with an interface:

public interface IMoneyTransferView
{
    string Account1ID { get; set; }
    string Account1Name { get; set; }
    string Account1Type { get; set; }
    string Account2ID { get; set; }
    string Account2Name { get; set; }
    string Account2Type { get; set; }
    string Description { get; set; }
    Currency Currency { get; }
    double Amount { get; set; }
    TransferType Type { get; set; }

    bool AskIfSure();
    void ShowMessage(string message);
    void DisplayDescriptionField();
    void HideDescriptionField();
    void PopulateCurrencyList(List<Currency> currencyList);
    bool AskQuestion(string message);
    void ExpandCurrencyBox();
    void SetDescriptionDifferentColor();
    void SetDescriptionNormalColor();
}

The frmMoneyTransfer implements IMoneyTransferView interface.

public partial class frmMoneyTransfer : Form , IMoneyTransferView
{
    ...
}

I’ll also need my MoneyTransferPresenter class

public class MoneyTransferPresenter
{
    ...
}

Connecting View and Presenter

The connection between View and Presenter is simple one, they hold references to each other. Here is the Presenter constructor:

public class MoneyTransferPresenter
{
    ...
    private IMoneyTransferView View { get; set; }
    public MoneyTransferPresenter(IMoneyTransferView view)
    {
        ...
        this.View = view;
        ...

    }
}

The View implementation also holds reference to Presenter

public partial class frmMoneyTransferFrom : Form , IMoneyTransferView
{    ...    
    MoneyTransferPresenter Presenter { get; set; }     
    public frmMoneyTransferFrom()    
    {        
        InitializeComponent();        
        this.Presenter = new MoneyTransferPresenter(this);     
    }    
    ...
}

Connection between Model and Presenter

This one is even simpler. Presenter holds reference to Model. The Model does not even need to know about that.

public class MoneyTransferPresenter
{
    ...
    private MoneyTransfer MoneyTransfer { get; set; }

    public MoneyTransferPresenter(IMoneyTransferView view)
    {
        ...
        this.MoneyTransfer = new MoneyTransfer();
        ...
    }
}

I have said earlier that:

“Events are received on View, the View passes them to Presenter.”

Here’s how it looks in practice when user presses Process Transfer button.

private void btnProcessTransfer_Click(object sender, EventArgs e)
{
    Presenter.ProcessTransfer();
}

The view only called Presenter.ProcessTransfer() method. Here’s another example:

private void txtAmount_TextChanged(object sender, EventArgs e)
{
    Presenter.AmountChanged(); 
}

I also said this:

“Presenter decides how and if the Model needs to be updated.”

public class MoneyTransferPresenter
{
    ...
    public void AmountChanged()
    {
        this.MoneyTransfer.Amount = View.Amount;
    }
    ...
}

Then again, I’ve said this as well:

“Presenter initiates any needed changes on the View”

Below, you can see how Presenter tells the View what to do and updates it appropriately:

public void DescriptionChanged()
{
    if (View.Description.Length > 20)
    {
        bool answer =
            View.AskQuestion(
                "Warning : Your description is larger then 20 characters. Your transfer may fail. Do you want to clear it?");
        if (answer == true)
        {
            View.Description = string.Empty;
        }
        else
        {
            View.SetDescriptionDifferentColor();
        }
    }
    else
    {
        View.SetDescriptionNormalColor();
    }
    MoneyTransfer.Description = View.Description;
}

What is the benefit of using MVP?

We’ve managed to control the complexity by separating concerns.
Code in frmMoneyTransfer form is simplified and easy to understand.
Code in Presenter is clean and simple because it accesses the View using well defined interface – IMoneyTransferView
We have better structure of the code which improves understandability, maintainability, readability.
We have got a more testable code.

Note on source code provided

I did not use any IoC container just to keep the code simpler and more focused on MVP pattern. That’s why I have things like new MoneyTransferPresenter() and new AccountRepository() all over the place.

I also strongly suggest you to go through the source code and examine the various parts of the application.

Conclusion

My conclusion is that, in absolutely all, but the most simplest situations, should MVP pattern be used when building presentation layers in Windows Forms. The pattern is easy to learn and the benefit of using it is great.

A good reading list

2010-02-04T07:16:00.001-08:00

Today, I found an interesting blog post that kind of represents a reading guide to becoming a better developer. I found it on The Inquisitive Coder blog, which I highly recommend. You can look at the original post here. The author separates reading list in three sections: Introduction, Design & Architecture, Team Environment. The author also thinks that it’s best to read the books exactly in given order. Anyway, here is the list:

Introduction

Design & Architecture

Team Environment

I already own following books from this list:

Code Complete: 2nd Edition (Steve McConnell)
Domain-Driven Design (Eric Evans)
Enterprise Integration Patterns (Gregor Hohpe, Bobby Woolf) – Still reading this one, now at chapter 5

Even though I’m not absolutely sure that this is the best order to read these books, I have decided to start reading Test-Driven Development (Kent Beck) first. It shouldn’t take long since it has around 240 pages. Currently, I’m at chapter 3, and I have to say I like the style of the book. It’s easy to follow and the author, Kent Beck, knows how to make a point. I also plan to introduce a new practice of reading one book each month. Two if time permits. This way, it will take me a year to read the all the books from the list. I’m pretty sure it will be worth the effort.

Digging deeper into Messaging

2010-02-02T14:23:00.001-08:00

Recently, I got interested into messaging. Messaging is simply one of the ways of building enterprise applications. When you live in .NET world, you can use one of the following frameworks to ease your way of building a messaging application:

I decided to go with NServiceBus and write an simple application just to get more sense about the overall approach. I liked what I saw. Messaging gives a whole new meaning to building robust, fault-tolerant, fast performing, loosely coupled enterprise applications. The framework itself is designed in a such way so that actual development is simplified to it’s maximum. My next step was to download NServiceBus source code to take a peek of how the things were done internally. This helped me to grasp core concepts better and faster. Since I liked the whole idea, I decided to take things even further and read the Enterprise Integration Pattern book which stands for one of the best on the subject. I would also like to look more into the NServiceBus source code. However, reading the book has a higher priority for now. If you’re new to messaging, I strongly recommend checking out following links:

Anyway, I’ll keep you posted on my progress and thoughts on this interesting subject.

Thoughts on OO design

2010-01-31T12:35:00.001-08:00

OO design is a creative activity. To be successful at it, you’ll need a mixture of both talent and learned skills. There is no such thing as correct design. There is only good, bad and somewhere-in-between design. OO program is simply a collection of objects that send messages to each other. But how do you design these objects? What objects to create? Which objects should interact? In my work, I usually begin OO design by identifying abstractions. I look at the problem from higher level. I try to identify abstractions that model true nature of the problem. An common mistake is to completely model real-world entities. In software development we have possibility of using abstractions to make our job/life easier. You should use this to your advantage. I assign each object a single responsibility. Note that assigning responsibilities is not easy at all. If you are good at assigning responsibilities then chances are, that you’re are good at OO designs too.

“Understanding responsibilities is key to good object-oriented design”—Martin Fowler

Once you’re done with the design, how do you know if it’s good or bad? There are two metrics/principles that you can evaluate your designs against. These are coupling and cohesion. These principles are very powerful in assisting you to make your OO designs good. Funnily, the principles don’t even come from OO, but from Structured design. Coupling is simply a degree to which each object is dependent on each one of the other objects (Wikipedia definition). Coupling quantifies the dependencies among objects. It can be loose or tight. Loose coupling is desired, since it’s more change-friendly. Fewer dependencies make introducing changes easier. Cohesion tells us how focused a class is in fulfilling its responsibility. Does a class have well defined responsibility? Are all parts of class (methods etc) focused on fulfilling that, and only that responsibility? High-cohesion is desired, since it promotes robustness, reusability, and understandability.

To sum up, here are the key concepts I use in my day-to-day OO design:

Abstractions
Responsibilities
Loose-coupling
High-cohesion

Following books helped me to gain more understanding of OO design:

Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development by Craig Larman. This book is a great place to start. It will teach you UML as well, and how to use it effectively.
Object Design: Roles, Responsibilities, and Collaborations by Rebecca Wirfs-Brock. I haven’t read it completely ,gets kind of boring at some parts, but there are some great insights on OO design.
Object-Oriented Design Heuristics by Arthur J. Riel – a bit old, but great book.

Final advice: The best way to become better at OO design is to do it a lot. A huge amount of it.

DRY – The first step

2010-01-30T05:48:00.001-08:00

It has been said that a thousand miles journey starts with a single step. So in case journey = becoming a better developer, then first step = DRY. DRY stands for Don’t Repeat Yourself. I see way too much copy-paste development around. This needs to stop. If you constantly copy-paste code around, you’re limiting yourself of becoming a better developer. Code duplication is evil, and it’s simply against common sense. So why do we do it? We do it probably because it’s easier, it doesn’t require us to think. When we stop thinking, our journey of becoming a better developer ends. Anyway, does anybody know how do you disable CTRL+C in VS :)?

Is anybody interested in open-source tool like Silverlight Spy?

2010-01-27T12:47:00.001-08:00

A few months ago I started to work on a Silverlight project. It was a business-line application, pretty much standard of that type. It was my first project in Silverlight. Anyway, soon I found this great tool called Silverlight Spy. It’s a tool for runtime inspection of Silverlight applications, something like Firebug but only for Silverlight. I was impressed with the software since it was very powerful. The tool costs around 99 EUR, which is not much for the value you get. However, as a passionate developer, I like to develop my own tools (during my free time of course:)). It was then the idea of similar open-source tool was born. I decided to develop a proof-of-concept application called Silverlight Buddy(now thinking of renaming it to Silverlight Inspector). Here’s the what I have done by now:

Intercepting Silverlight application before it’s displayed in browser
Injection of custom code logic into an Silverlight application
Solved communication between Silverlight application and Silverlight Buddy tool. (both using COM and JavaScript)
Support for hosting DLR inside Silverlight applications (Just like in Silverlight Spy)
Very basic “Inspect Element”-like functionality

The app is not stable since it is intended only to be a proof-of-concept, written in a quick-and-dirty way. But as you can see, all the major issues/parts have been solved. There is still a huge amount of work to be done in order to make it a usable application. Now,I have never run open-source project, and to be honest, I don’t have time to. That’s why I thought there was somebody out there willing to continue to work on the project. I will probably be a committer myself, but don’t have time to devote fully to the project. If somebody is interested please write a comment.

Here are some screenshots of the app so far.

Notice the red border around “Search” textbox, it represents “Inspect Element” functionality as you move your mouse over the elements.

I hope someone will be willing to continue the work on this project so the effort I have made so far will not be wasted.

ASP.NET : Using ClientID in external JavaScript files

2009-08-15T10:34:00.001-07:00

In the past year I have been writing a lots of JavaScript code. Mostly because I have been working on same ASP.NET WebForms application for more then 10 months by now. We use JavaScript for things like validation, async HTTP requests etc. To keep our code clean,we try to keep all of our JavaScript in external files. The problem with external JavaScript files is that you cannot use server tags in them, so you cannot obtain ClientID of ASP.NET controls by using <%= control.ClientID %> syntax. My first workaround for this problem was to add JavaScript variables manually on every page by using ClientScript.RegisterClientScriptBlock() method. Every page needed to have a collection of controls which was called JSControls. In the Page_Load event of the page I would add to JSControl collection all controls for which I need access from JavaScript. Code would look like this:

private List<Control> JSControls = new List<Control>();
protected void Page_Load(object sender, EventArgs e)
{
     JSControls.Add(txtName);
     JSControls.Add(txtLastname);
}

Then I had a function that would generate JavaScript code for each control in JSControl collection:

public static string GetClientScriptBlock()
{
StringBuilder sb = new StringBuilder();
sb.Append("<script type=\"text/javascript\">");
foreach (Control c in JSControls)
{
    if (c != null)
    {
        sb.Append(string.Format("var {0} = '{1}';", c.ID + "ClientID", c.ClientID));
    }
}
sb.Append("</script>");
return sb.ToString();
}

Then, again in the Page_Load event I needed to call RegisterClientScriptBlock with JavaScript code block:

protected void Page_Load(object sender, EventArgs e)
{
JSControls.Add(txtName);
JSControls.Add(txtLastname);                         
Page.ClientScript.RegisterStartupScript(this.GetType(), "myClientBlock", GetClientScriptBlock(), false);
}

This works fine, so if I need to access for example ClientID of TextBox control called txtName I would just refer to txtNameClientID variable, like this:

document.getElementById(txtNameClientID);

While this approach is fine it has some disadvantages. One problem is that there could be controls with same ID but in different parent controls. Another disadvantage is that this approach is not very reusable, it would force me to violate DRY principle, since the same code had to be added to every page.

A better solution

There is a better solution. A reusable custom control can be created to automate JavaScript variable creation for us. The idea is to put the control on a Page, define for which controls from the page you need ClientID’s and the control would do the rest of the work. The custom control would also have some kind of Namespace property, that would solve the problem with same ID on different controls. Design-Time support would also be nice to have here, since we would not need to write control id's manually. Let’s make our idea to realization!

Control syntax

Goal is to have control with syntax as simple as possible. Suppose that we call our control JSClientIDList, we want to have syntax like this:

<ReducingComplexity:JSClientIDList runat="server" ID="JSClientIDList1" Namespace="namespace1">
<JSControls>
    <ReducingComplexity:ControlItem ControlID="btnOK" />
</JSControls>
</ReducingComplexity:JSClientIDList>

We see that this syntax is very straightforward. JSClientIDList control has two important properties. The first one is Namespace property, which defines some kind of prefix for each of the controls. The second important property is JSControls which defines list of ASP.NET controls for which JavaScript variables will be created. We will need another class for representing a control in our JSControls list. We will call that class ControlItem. The whole code would look like this:

using System;
using System.Collections.Generic;
using System.Web;
using System.Web.UI;
using System.ComponentModel;
using System.Diagnostics;
using System.Web.UI.WebControls;
using System.Text;

namespace ReducingComplexity.Web.Controls
{
[PersistChildren(false)]
[ParseChildren(true)]
public class JSClientIDList : Control
{
    private string m_Namespace;
    [Browsable(true)]
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
    public string Namespace
    {
        get
        {
            return m_Namespace;
        }
        set
        {
            m_Namespace = value;
        }
    }

    [Browsable(true)]
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
    [PersistenceMode(PersistenceMode.InnerProperty)]
    public List<ControlItem> JSControls { get; set; }

    public JSClientIDList()
    {
        JSControls = new List<ControlItem>();
    }
    protected override void OnPreRender(EventArgs e)
    {
        Page.ClientScript.RegisterClientScriptBlock(this.Parent.GetType(),this.ClientID, GetClientScriptBlock(), true);
        base.OnPreRender(e);
    }
    protected override void AddParsedSubObject(object obj)
    {
        if (obj is ControlItem)
        {
            this.JSControls.Add((ControlItem)obj);
            return;
        }
    }
    private string GetClientScriptBlock()
    {
        StringBuilder sb = new StringBuilder();
        sb.AppendFormat("var {0}=new Object();", this.Namespace);
        foreach (ControlItem ci in this.JSControls)
        {
            Control c = this.FindControl(ci.ControlID);
            string clientId = c != null ? c.ClientID : "";
            sb.AppendFormat("{0}.{1}='{2}';", this.Namespace, ci.ControlID, clientId);
        }
        Debug.WriteLine(sb.ToString());
        return sb.ToString();
    }
}
public class ControlItem
{
    [TypeConverter(typeof(ControlIDConverter))]
    public string ControlID { get; set; }
}
}

I’ll try to explain most important parts of the code. To enable clean syntax we needed to use PersistChildren and ParseChildren attributes. These attributes define how nested content of the control will be interpreted. More details can be found here. Next we also needed to override AddParsedSubObject method, which will add nested controls to JSControls collection.

protected override void AddParsedSubObject(object obj)
{
if (obj is ControlItem)
{
      this.JSControls.Add((ControlItem)obj);
      return;
}
}

Another interesting part is usage of ControlIDConverter as TypeConverter. This will enable us to use Design-Time support for ControlID property, or to be more precise it will provide dropdown list of all controls available for addition, so that we can choose from the list.

When I first started implementing this functionality I didn’t really know about ControlIDConverter class. My plan was to write my own Type Converter which would provide such functionality, but I failed. To cut the long story short,the reason I failed was I didn’t know I could use GetService() function of ITypeDescriptorContext interface to get the instance of IDesignerHost. Anyway, Reflector reveals all the secrets:

We can also see that the actual registration of JavaScript code block is done in OnPreRender event since in this event all controls in Control collection are available.

For example if we define Namespace property to “Namespace1” and have a ASP.NET button control with ID "btnOK" then to get ClientID of the btnOK button from external JavaScript file we would use following syntax:

document.getElementById(Namespace1.btnOK);

And of course JSClientIDList control would have to be declared like this:

<ReducingComplexity:JSClientIDList runat="server" ID="JSClientIDList1" Namespace="namespace1">
      <JSControls>
          <ReducingComplexity:ControlItem ControlID="btnOK" />
      </JSControls>
</ReducingComplexity:JSClientIDList>

By using this simple control our goal of using external files for JavaScript code has been achieved.

Good design comes over time

2009-08-14T05:58:00.001-07:00

Have you ever tried to provide design for Mark IV coffee maker problem that Robert C. Martin presented in his "Designing Object Oriented C++ Applications using the Booch Method" book. Well I have and I was not successful to come up with any kind of elegant solution. But I was quite impressed with the solution that Uncle Bob presented for this design problem. You can find the solution here.

What I find interesting in the above document is section titled "How did I really come up with this design?". In that section Uncle Bob says:

I did not just sit down one day and develop this design in a nice straightfoward manner. Indeed, my very first design for the coffee maker looked much more like Figure 11–1. However,I have written about this problem many times, and have used it as an exercise while teaching class after class. So this design has been refined over time.

This paragraph was very encouraging to me, because as you see even Robert C. Martin himself did not get it right the first time. We are not going to get it right the first time, no matter how much we try. Good designs come over time, they are not obvious immediately. Our initial design will change over time, and we need to ensure that changes that happen will lead to better design. I see great power in refactoring here. By doing refactoring we change design of our software to something better and still preserve clean and maintainable code. Unit testing and TDD in general is of great help here as well. It is the immediate feedback that makes us less fearful of making changes to our code.

Pseudocode Programming Process

2009-08-11T11:06:00.001-07:00

Today I had to implement a feature on project I'm working on. The feature was not a trivial one. It was rather complex. I had a general idea how it could be implemented. The implementation I was having in mind involved several complex data structures and some recursion function calls as well. After short thinking about the problem I started to do the actual implementation in C#. To be more precise I tried several implementations, but I kept failing, and found myself rewriting the code over and over. I was completely lost in complexity of the problem and all the details (complex data structures and recursion calls). I kept doing so for about 1.5 hours (maybe two), and I still had no working solution. Then I realized that I have to change my problem solving approach.

If you have read "Code complete" book you probably remember Pseudocode Programming Process (PPP) that Steve described in the book. Pseudocode Programming Process is a way of designing algorithms in pseudo code. Basically, this means that an algorithm is described in high-level English-like way. You can find more about the PPP on following links:

Anyway, after writing down the algorithm in high-level English and then making every line of comment into a line or fewof code (applying PPP practices), I had working solution in about 20 minutes. YES, 20 minutes including pseudocode and C# implementation. How that compares to 1.5 hours spent for literally nothing? I can only but recommend PPP as way of handling complex algorithms.

Bugs and bytes

2009-08-06T14:22:00.001-07:00

Yesterday, at work we had a bug in application we’re developing. Nothing critical but rather inconvenient. Our application has a very common functionality of file download. Some users can upload files to the system and some other users can download those files. Pretty straightforward functionality, right? It’s an ASP.NET application so it should be very easy to implement this. Here's the code (not the real code but the relevant part of it):

 protected void ViewFile(int fileId)
       {
           byte[] fileData = DAL.GetFile(fileId);
           Response.ContentType = "application/octet-stream";
           Response.AddHeader("Content-Disposition", "attachment; filename=test.txt");
           Response.OutputStream.Write(fileData, 0, fileData.Length);
           Response.End();
       }

So what could possibly go wrong here? Not much? Except…, files can be EMPTY too! An empty file is a file that is 0 bytes in size. So if you try to write an empty file with the code above an exception would be throw at Response.OutputStream.Write() line. How do we write an empty file to HttpResponse then? Very simple: you DONT write anything. Just skip Response.OutputStream.Write line and call the Response.End(). Anyway, what am I trying to prove here with this simple example? My point is that we need to be more thoughtful when writing code. We must carefully think about code we write. What could go wrong? How is API we’re using behaving? What exceptions can be thrown? What assumptions are being made? One approach I find useful with dealing this kind of issues is Defensive programming. Here’s quote from wiki about Defensive programming:

A difference between defensive programming and normal practices is that few assumptions are made by the programmer, who attempts to handle all possible error states. In short, the programmer never assumes a particular function call or library will work as advertised, and so handles it in the code.

If the code had been written in Defensive programming mind-set this bug would have never been made. I must also note that Defensive programming is not only choice for solving these kind of issues. Another approach is Design by contract. In the end it really does not matter which approach you choose, the goal is to create more robust and quality software.

Strings and performance

2009-08-05T07:18:00.001-07:00

I really cannot stress enough importance of using StringBuilder class for string concatenation. The reason is obvious: PERFORMANCE! I know that most programmers are aware of the possible string concatenations performance problems but somehow this issue is still being overlooked and many make the mistake.The difference in performance between using and not using StringBuilder is HUGE as I'll show in simple demo application. I'm not saying that you should use StringBuilder for every string concatenation, but be very alert when you have loops that do string concatenation. Stop for a minute and think about possible performance issues. How much iteration do you expect your loop to have? If you loop through collection that you expect to get bigger and bigger over time, or a collection that you know nothing about (such as one coming from external system) then using StringBuilder has no alternative. Let's take a look how long does it take to do for example 30 000 string concatenations. by using StringBuilder. Code looks as follows :

class Program
  { 
      static void Main(string[] args) 
      { 
          StringBuilder sb = new StringBuilder(); 
          DateTime start = DateTime.Now;  
          for (int i = 0; i <30000; i++) 
          { 
              sb.Append("some string"); 
          } 
          TimeSpan ts = DateTime.Now - start;  
          Console.WriteLine("Finished!"); 
          Console.WriteLine(ts.TotalSeconds); 
          Console.ReadLine(); 
      } 
}

On my computer it takes exactly 0.15625 seconds which is very very fast.

Now let's take a look at same code but without using StringBuilder

 class Program
  { 
      static void Main(string[] args) 
      { 
          string str= string.Empty; 
          DateTime start = DateTime.Now;  
          for (int i = 0; i <30000; i++) 
          { 
              str+= "some string"; 
          } 
          TimeSpan ts = DateTime.Now - start;  
          Console.WriteLine("Finished!"); 
          Console.WriteLine(ts.TotalSeconds); 
          Console.ReadLine(); 
      } 
  }

Without StringBuilder it takes 21.396625 seconds.

Difference in performance is very noticeable and benefit of using StringBuilder is obvious. It's worth noting that performance issues are usually not discovered until system has been deployed and used in production, but by that time damage can already be done. That's why string concatenation must be taken with care.

Tip on employing the domain model pattern

2009-08-03T02:21:00.001-07:00

Today, I read Udi's latest article about domain model pattern published in MSDN magazine. I want to comment on following part of the article:

When designing a domain model, spend more time looking at the specifics found in various use cases rather than jumping directly into modeling entity relationships—especially be careful of setting up these relationships for the purposes of showing the user data. That is better served with simple and straightforward database querying, with possibly a thin layer of facade on top of it for some database-provider independence.

Udi couldn't be more right here. I had similar dilemma few weeks ago,and my reasoning happened to be same as Udi's. I had an association that seemed so natural and correct. Association was as follows:

But after looking deeper at problem I was trying to solve it turned out that this association was only needed for presentation purposes. So I dropped the association altogether from the domain model. Presentation issue was solved by using a simple query (using NHibernate). This shows that domain model should be used for capturing core business behavior only. In the article Udi also wrote about Domain Events pattern that can help solve complex problems quite elegantly. I strongly recommend reading this article.

Fluent ADO.NET. An attempt!

2009-07-16T14:16:00.001-07:00

Yes, I know there is NHibernate and other decent ORM solutions but, there are times when using an ORM is not an option. Still the ADO.NET API is VERY boring thing to use. Yes, you can make some SqlHelper classes that can help you but still many of the SqlHelpers lack the needed flexibility. So, I’ll try to make a Fluent wrapper for ADO.NET API.

What are we trying to achieve?

Our goal is to make usage of ADO.NET API more friendly and easier. So let’s start with some examples of our desired code usage.

Wouldn’t it be nice if we could use SqlCommand object in following way?

SqlCommand command = new SqlCommand();
SqlConnection connection = new SqlConnection();
command.UsingConnection(connection)
.ExecuteQuery("SELECT * FROM USERS WHERE ID=@id")
.AddParameter("@id",    1)
.AsDataTable();

or..

SqlCommand command = new SqlCommand();
SqlConnection connection = new SqlConnection();
command.UsingConnection(connection)
.ExecuteQuery("UPDATE Users SET Active=1 WHERE ID=@id")
.AddParameter("@id",1)
.ExecuteNonQuery();

Note: Before we go further with this fluent ADO.NET I need to say that there is already an open source project related to ADO.NET fluent interface. As a matter of fact I had a short discussion with coordinator of the project about some design aspects of the API. The design differences between the two approaches are related to supporting different database engines. You can read about this short discussion here.

How to achieve our goal?

To achieve usage of SqlCommand as shown above, we can go and write wrapper around SqlCommand object and that would definitely work. But what if I need to use Access as data source? In that case I wouldn’t be using the SqlCommand class, I would be using OleDbCommand instead. To avoid writing wrapper around all possible (Oracle,Postgre,MySql) databases, we can instead write wrapper around IDbCommand interface which all of the specific commands implement. This approach is rather good, but has some major drawback. Problem is that we would not be able to take advantage of specific features that are available on some of the IDbCommand implementations. One such property on SqlCommand object is "Notification", which is not present in IDbCommand interface.

To get around this problem we could make use of extension methods, which could be written in fluent approach and thus enable that specific features of IDbCommand implementations can be configured fluently. So let’s start the implementation.

The implementation

Please note that I will not be implementing whole API, but I’ll only show the concept.

Our wrapper class will be called FluentDbCommand, it is generic class that receives a IDbCommand as the type parameter. Here’s the code listing:

public class FluentDbCommand<T>
where T : IDbCommand
{
    T command = default(T);
    Func<T> commandConstructor = null;

    public T InnerCommand
    {
        get
        {
            return command;
        }
    }
    public FluentDbCommand()
    {
        // In case we don't provide any factory for creating command objects
        // try to build the object using reflection
        command = Activator.CreateInstance<T>();
    }
    public FluentDbCommand(Func<T> commandConstructor)
    {
        this.commandConstructor = commandConstructor;
        command = this.commandConstructor.Invoke();
    }

    public FluentDbCommand<T> AddParameter(string name, object value)
    {
        IDbDataParameter parameter = command.CreateParameter();
        parameter.ParameterName = name;
        parameter.Value = value;
        command.Parameters.Add(parameter);
        return this;
    }
    public FluentDbCommand<T> QueryToRun(string query)
    {
        command.CommandType = CommandType.Text;
        command.CommandText = query;
        return this;
    }
    public DataTable AsDatatable()
    {
        DataTable tblResults = new DataTable();
        tblResults.Load(command.ExecuteReader());
        return tblResults;
    }
    public FluentDbCommand<T> UseConnection(IDbConnection connection)
    {
        this.command.Connection = connection;
        return this;
    }
    public int ExecuteNonQuery()
    {
        return this.InnerCommand.ExecuteNonQuery();
    }
    public object ExecuteScalar()
    {
        return this.InnerCommand.ExecuteScalar();
    }
    public IDataReader ExecuteReader()
    {
        return this.InnerCommand.ExecuteReader();
    }
    public FluentDbCommand<T> RunStoredProcedure(string strProcedureName)
    {
        this.InnerCommand.CommandType = CommandType.StoredProcedure;
        this.InnerCommand.CommandText = strProcedureName;
        return this;
    }
}

And usage of the FluentDbCommand would be:

FluentDbCommand<OleDbCommand> oleCmd = new FluentDbCommand<OleDbCommand>();

DataTable result = oleCmd.UseConnection(connection)
                 .QueryToRun("SELECT * FROM USERS")
                 .AddParameter("@id", 1)
                 .AsDatatable();

We see that it’s rather simple to implement the fluent interface around IDbCommand, but as I said earlier, to support the specific features of concrete database engine we need to use extension methods.

For example to support NotificationAutoEnlist property of SqlCommand class we would need to write following extension method

public static class SQLServerSpecificExtensions
{
public static FluentDbCommand<SqlCommand> NotificationAutoEnlist(this FluentDbCommand<SqlCommand> command, bool value)
{
command.InnerCommand.NotificationAutoEnlist = true;
return command;
}
}

And that would enable us to use the FluentDbCommand in following way:

FluentDbCommand<SqlCommand> sqlCmd = new FluentDbCommand<SqlCommand>();

sqlCmd.UseConnection(connection)
            .QueryToRun("SELECT * FROM USERS WHERE ID=@id")
            .AddParameter("@id", 1)
            .NotificationAutoEnlist(true)
            .AsDatatable();

That would be it. This implementations is just a beginning of the full-blown wrapper, but it’s shows the concept very well.

Book review – Pro ASP.NET MVC (Steven Sanderson)

2009-07-11T15:35:00.001-07:00

I decided to purchase this book after seeing good reviews of this book at Amazon. I must say that reviews at Amazon can sometimes misguide you but this time I was lucky. This book is outstanding, it is full of details about ASP.NET MVC and the author knows his stuff. Another good thing about this book is author’s writing style, which is entertaining and easy to follow. The book is divided in two parts, first part is about building small e-commerce book with ASP.NET MVC framework and second part is about detailed explanations of ASP.NET MVC Framework inner details. As a matter of fact this book contains so much valuable technical information about MVC framework that I’ll surly need to read some parts again.

Conclusion: If you plan to do any serious development with ASP.NET MVC then this book is must-have for you.

The author of this book also has a blog that is worth checking out.