Thoughts of a .NETer

Adding dynamic ‘where’ clauses to a linq query using Builder and Specification pattern

2012-01-15T12:31:00.000+05:30

On-the-fly building on where clauses of query statements tofire against a data store is a common problem in most of the applications. Linqis a concept of querying data a first class programming concept in .NET, andenables you to efficiently express queries in your programming language ofchoice. Linq allows you to write type-safe queries, most of the times you needto construct queries on the fly based on some filter conditions.

The Dynamic query library provided by Microsoft helps you toconstruct linq queries by passing a string value for where condition or anexpression that can be evaluated at runtime. In this post we'll see how toconstruct expressions for the where clause dynamically using a combination ofbuilder and specification pattern.

Creating a class for filter options

public class UsersFilterOption

{

public string Name { get; set; }

public string Country{ get; set; }

public string Role { get; set; }

public string Email {get; set; }

public stringTelephone { get; set;}

}

The condition builder class is used to add expressions as specifications to the Specification based on the filter options.

public class UserWhereConditionExpressionBuilder

{

private readonly UsersFilterOption _filterOptions;

private Specification<User> _result = newTrueSpecification<User>();

public UserWhereConditionExpressionBuilder(UsersFilterOption usersFilterOptions)

{

_filterOptions = usersFilterOptions;

}

public UserWhereConditionExpressionBuilderName()

{

var shouldBuild = !string.IsNullOrEmpty(_filterOptions.Name);

if (!shouldBuild) returnthis;

_result &= new DirectSpecification<User>(u=> u.Name.ToUpper().Contains(_filterOptions.Name.ToUpper()));

return this;

}

public UserWhereConditionExpressionBuilderEmail()

{

var shouldBuild = !string.IsNullOrEmpty(_filterOptions.Email);

if (!shouldBuild) returnthis;

_result &= new DirectSpecification<User>(u=> u.Email.ToUpper().Contains(_filterOptions.Email.ToUpper()));

return this;

}

public UserWhereConditionExpressionBuilderCountry()

{

var shouldBuild = !string.IsNullOrEmpty(_filterOptions.Country)&&

System.String.CompareOrdinal(_filterOptions.Country, "ALL") != 0;

if (!shouldBuild) returnthis;

_result &= new DirectSpecification<User>(u=> System.String.Compare(u.Country,_filterOptions.Country, System.StringComparison.OrdinalIgnoreCase)== 0);

return this;

}

public UserWhereConditionExpressionBuilderRole()

{

var shouldBuild = !string.IsNullOrEmpty(_filterOptions.Role)&&

System.String.CompareOrdinal(_filterOptions.Role, "ALL") != 0;

if (!shouldBuild) returnthis;

_result &= new DirectSpecification<User>(u=> System.String.Compare(u.Role,_filterOptions.Role, System.StringComparison.OrdinalIgnoreCase)== 0);

return this;

}

public Specification<User> GetWhereCondition()

{

return _result;

}

The construct method on the builder class constructs the expression from the condition builder class. I've implemented the condition builder class as fluent interfaces for easy use.

public class UsersWhereCondition

{

public static ISpecification<User>Construct(UsersFilterOption filterOptions)

{

var builder = new UserWhereConditionExpressionBuilder(filterOptions);

return

builder

.Name()

.Email()

.Country()

.Role()

.GetWhereCondition();

}

Using these classes you can construct the query condition forthe dynamic linq clause as given below

var whereCondition = UsersWhereCondition.Construct(filterOptions);

var data = from user in userFactory.GetAll()

.Where(whereCondition.SatisfiedBy());

Aspect Oriented Programming and Interceptor pattern - Creating a Session handler for ASP.NET

2011-12-09T11:01:00.001+05:30

Interceptor pattern can be used for addressing cross cuttingconcerns in the application that happens at either the beginning or end of amethod. For e.g. checking the validity of the input parameters before executingthe method and throwing exceptions, catching and logging exceptions etc. Thesesituations can be encapsulated in a reusable component that can be processed bythe compiler and produce executable code (AOP).

Unity allows developers to implement the idea ofinterception by allowing creation of objects that can add some extra code onthe target method before or after the regular execution of these targetmethods. In this post, I'll show how to create a Session handler for ASP.Netusing the interface interception mechanism provided by unity application block,that will allow you to address encapsulate the logic for checking session for avalue before execution of the method and returning back the value from sessionif available. The same handler can be used to also add the return value to thesession if not available so that this value can be retrieved next time.

Creating the session handler

public class SessionHandler : ICallHandler

{

private readonly string _sessionKey;

public SessionHandler(stringsessionKey)

{

_sessionKey = sessionKey;

}

public ISessionServiceSessionService

{

get { return Container.Instance.Resolve<ISessionService>(); }

}

public IMethodReturnInvoke(IMethodInvocation input, GetNextHandlerDelegate getNext)

{

if (SessionService.Contains(_sessionKey))

{

input.CreateMethodReturn(SessionService.Get(_sessionKey));

return getNext()(input, getNext);

}

var returnValue = getNext()(input, getNext);

SessionService.Add(_sessionKey,returnValue.ReturnValue);

return returnValue;

}

public int Order { get; set; }

}

The session handler uses the session service whichencapsulates the actual Session object to add/ remove values from thesession. You can also use theHttpContext.Current.Session object here.

Creating the Attribute for the handler

public class SessionDependencyAttribute : HandlerAttribute

{

private readonly string _sessionKey;

public SessionDependencyAttribute(string sessionKey)

{

_sessionKey = sessionKey;

}

public override ICallHandler CreateHandler(IUnityContainer container)

{

return new SessionHandler(_sessionKey);

}

Creating a service and using the SessionHandler we created.

public interface IMockService

{

[SessionDependency("TestKey")]

string GetValue(boolflag);

}

public class MockService : IMockService

{

public stringGetValue(bool flag)

{

return flag ? "True": "False";

}

Configuring the Unity container

_container = new UnityContainer();

_container.AddNewExtension<Interception>();

_container

.RegisterType<ISessionService, SessionService>()

.RegisterType<IMockService, MockService>()

.RegisterType<MockPresenter>()

.Configure<Interception>().SetDefaultInterceptorFor<IMockService>(newInterfaceInterceptor());

Test cases

[TestMethod]

public voidMethodShouldReturnValueFromSessionIfValueDoesNotExistsAndAddToSession()

{

var service = Container.Instance.Resolve<IMockService>();

var actual = service.GetValue(true);

Assert.IsTrue(SessionService.Contains("TestKey"));

}

Using Unity to Resolve Instances based on condition

2011-11-28T15:25:00.001+05:30

Unity is a lightweight, extensible dependency injectioncontainer with support for nested containers that stores registrations andmappings between types and can instantiate the appropriate concrete types ondemand. Identification of the registrations in unity can be done using a typeand a name (optional).

You can use unity to register multiple implementations ofthe same type and later resolve the actual instance by passing the name foridentifying the actual implementation. In this post we'll see how to resolvethe instances registered in unity application block conditionally.

For e.g. I have created a sample interface andimplementations as given below

public interface IMyObject

{

string DoSomething();

}

public class MyObjectFirstImplementation : IMyObject

{

public stringDoSomething()

{

return "First";

}

public class MyObjectSecondImplementation : IMyObject

{

public stringDoSomething()

{

return "Second";

}

The registration of these components are done like

container

.RegisterType<IMyObject, MyObjectFirstImplementation>(DependencyRegistrationKeys.FirstImplementation)

.RegisterType<IMyObject, MyObjectSecondImplementation>(DependencyRegistrationKeys.SecondImplementation);

public static class DependencyRegistrationKeys

{

public const string FirstImplementation = "FIRST_IMPLEMENTATION";

public const string SecondImplementation = "SECOND_IMPLEMENTATION";

}

The factory class has a create method that accepts andobject key to resolve the actual instances

public class MyObjectFactory

{

public IMyObjectCreate(string objectKey)

{

return Container.Instance.Resolve<IMyObject>(objectKey);

}

Tests

[TestMethod]

public voidCreateMethodShouldReturnTheObjectImplementationBasedOnConditionPassed()

{

var factory = new MyObjectFactory();

var myObject = factory.Create(DependencyRegistrationKeys.FirstImplementation);

Assert.IsInstanceOfType(myObject, typeof(MyObjectFirstImplementation));

}

The Specification Pattern - A Generic implementation

2011-11-21T20:42:00.000+05:30

In this post I’m going to create a generic implementation ofthe specification pattern.

The central idea of Specification is to separate thestatement of how to match a candidate, from the candidate object that it ismatched against. As well as its usefulness in selection, it is also valuableforvalidation and for building to order. Every specification implementationneeds to specify a method that evaluates a condition mentioned in the interfaceIspecification as given below.

public interface ISpecification whereT : class

{

Expression<Funcbool>> SatisfiedBy();

}

The generic specification class implements the Ispecificationinterface as

public sealed class Specification: ISpecification where T : class

{

readonly Expression<Funcbool>>_matchingCriteria;

public Specification(Expression<Funcbool>>matchingCriteria)

{

if (matchingCriteria == null)throw new ArgumentNullException("matchingCriteria");

_matchingCriteria = matchingCriteria;

}

public Expression<Funcbool>>SatisfiedBy()

{

return _matchingCriteria;

}

Using this implementation we can create the ANDspecification as

public sealed class AndSpecification: ISpecification where T : class

{

private readonly ISpecification _rightSideSpecification;

private readonly ISpecification _leftSideSpecification;

public AndSpecification(ISpecificationleftSide, ISpecification rightSide)

{

if (leftSide == null)throw new ArgumentNullException("leftSide");

if (rightSide == null)throw new ArgumentNullException("rightSide");

_leftSideSpecification = leftSide;

_rightSideSpecification = rightSide;

}

public ISpecificationLeftSideSpecification

{

get { return_leftSideSpecification; }

}

public ISpecificationRightSideSpecification

{

get { return_rightSideSpecification; }

}

public Expression<Funcbool>>SatisfiedBy()

{

var left = _leftSideSpecification.SatisfiedBy();

var right = _rightSideSpecification.SatisfiedBy();

return (left.And(right));

}

The AND method is an extension method on the ISpecification andExpression<Funcbool>> types

public static ISpecification AND(this ISpecificationleftSpecification, ISpecificationrightSpecification) where T : class

{

return new AndSpecification(leftSpecification,rightSpecification);

}

public static Expression Compose(this Expressionfirst, Expression second,

Func<Expression,Expression, Expression>merge)

{

var map =

first.Parameters.Select((f, i) => new{f, s = second.Parameters[i]}).ToDictionary(p => p.s, p => p.f);

var secondBody = ExpressionTreeParameterReplacer.ReplaceParameters(map,second.Body);

return Expression.Lambda(merge(first.Body,secondBody), first.Parameters);

}

public static Expression<Funcbool>> AND(this Expression<Funcbool>>first,

Expression<Funcbool>> second)

{

return first.Compose(second, Expression.And);

}

The ExpressionTreeVisitor implementation to replace and jointhe parameters for these extension methods

public sealed class ExpressionTreeParameterReplacer: ExpressionVisitor

{

private readonly Dictionary<ParameterExpression,ParameterExpression> _map;

public ExpressionTreeParameterReplacer(Dictionary<ParameterExpression,ParameterExpression> map)

{

_map= map ?? new Dictionary<ParameterExpression, ParameterExpression>();

}

public static Expression ReplaceParameters(Dictionary<ParameterExpression,ParameterExpression> map,

Expression exp)

{

return new ExpressionTreeParameterReplacer(map).Visit(exp);

}

protected override Expression VisitParameter(ParameterExpressionp)

{

ParameterExpression replacement;

if (_map.TryGetValue(p, outreplacement))

p= replacement;

return base.VisitParameter(p);

}

Now let’s look at a sample using the specification patternimplementation.

public class Customer

{

public stringFirstName { get; set;}

public stringLastName { get; set;}

public stringUserName { get; set;}

public DateTimeDateOfJoining { get; set;}

public AddressAddress { get; set;}

}

public class Address

{

public string Street{ get; set; }

public string State {get; set; }

public string City { get; set; }

public string Country{ get; set; }

}

public class CountryNameSpecification : ISpecification<Customer>

{

private readonly string _countryName;

public CountryNameSpecification(string countryName)

{

_countryName = countryName;

}

public Expression<Func<Customer,bool>> SatisfiedBy()

{

return new Specification<Customer>(c=> c.Address.Country.Contains(_countryName)).SatisfiedBy();

}

public class CustomerFirstNameSpecification :ISpecification<Customer>

{

private readonly string _firstName;

publicCustomerFirstNameSpecification(stringfirstName)

{

_firstName = firstName;

}

public Expression<Func<Customer,bool>> SatisfiedBy()

{

return new Specification<Customer>(c=> c.FirstName.Equals(_firstName)).SatisfiedBy();

}

[TestMethod]

public voidAndSpecificationShouldSatisfyIfBothExpressionsSatisfiesTheCondition()

{

var customers = GetAllCustomers();

var fooCountrySpecification = new CountryNameSpecification("Foo");

var customerFirtNameSpecification = new CustomerFirstNameSpecification("Foo4");

var andSpecification =fooCountrySpecification.AND(customerFirtNameSpecification);

var results =customers.Where(andSpecification.SatisfiedBy());

Assert.IsTrue(results.ToList().All(c =>c.Address.Country.Contains("Foo")&& c.FirstName.Equals("Foo4")));

}

[TestMethod]

public voidOrSpecificationShouldSatisfyIfOnOfTheConditionsSatisfiesTheSet()

{

var customers = GetAllCustomers();

var fooCountrySpecification = new CountryNameSpecification("Foo");

var abcCountrySpecification = new CountryNameSpecification("Abc");

var pqrCountrySpecification = new CountryNameSpecification("Pqr");

var orSpecification =fooCountrySpecification.OR(abcCountrySpecification).OR(pqrCountrySpecification);

var results =customers.Where(orSpecification.SatisfiedBy());

Assert.IsTrue(results.Count() ==customers.Count());

}

Where GetAllCustomers return an Iqueryable resultset ofcustomers with addresses.

Continuous Deployment – Automating ASP.Net web deployment using TeamCity and MSBuild

2011-09-14T23:28:00.000+05:30

“Of all the Lean Startup techniques, Continuous Deployment is by far the most controversial. Continuous Deployment is a process by which software is released several times throughout the day – in minutes versus days, weeks, or months. Continuous Flow Manufacturing is a Lean technique that boosts productivity by rearranging manufacturing processes so products are built end-to-end, one at a time (using singe-piece flow), versus the more prevalent batch and queue approach.

Continuous Deployment is Continuous Flow applied to software. The goal of both is to eliminate waste. The biggest waste in manufacturing is created from having to transport products from one place to another. The biggest waste in software is created from waiting for software as it moves from one state to another: Waiting to code, waiting to test, waiting to deploy. Reducing or eliminating these waits leads to faster iterations which is the key to success.” – Eric Ries

Continuous deployment is one of the new trends in agile development that ensures release of software in a faster and reliable manner. It also helps the team to deliver value to customers early and often. In this post I’ll show how to setup a continuous integration environment using TeamCity and MSBuild scripts created by using a Web deployment project deploy your website every time a check in happens into the source safe.

TeamCity is a user-friendly continuous integration (CI) server from jet brains that is available as a free download from the vendor website. You can use go to the website http://www.jetbrains.com/teamcity/ to get your free copy. I have also used the Web deployment project from MS for MSBuild script generations in this sample.

For setting up the automated deployment on a website, you can follow the below given steps.

Right click on the web application project for automated build and select Add Web Deployment Project

On the ‘Add Web Deployment Project’ dialog give an appropriate name for the deployment project and press OK. This web deployment project created for the web application is the build scripts for MSBUILD.

Next we can create the build configuration setup for the project. For this right click the solution and select Configuration manager.
Unselect the build option for ‘Debug’ and ‘Release’ configurations for the Deployment project.

On the Active solution configuration drop down select ‘New’

On the ‘New Solution Configuration’ dialog, enter the name for the deployment configuration and press OK. Close the configuration manager window by selecting Close.

Next we’ll create separate configuration options for staging environment. For e.g. the connection strings for the staging server will be different that the development environment. Right click the web application and add a new folder ‘Configuration’
In the Configuration folder add a new configuration file ‘ConnectionStrings.Staging.Config’ and include the connection strings for the staging environment in this file. These settings will be replaced with the connection strings section in the web.config file when the deployment is started.

We’ll now setup the deployment properties for the project. For that, right click the deployment project and select property pages.
Change the output folder to the location where the build output will be deployed to.

On the deployment section of the property pages, you can set transformations on the configuration options for the application. You can also mention the virtual directory options on this page. Save the settings by selecting OK.

Next we have to configure the project on Team city. Login to team city as administrator and navigate to the Administration tab. On the administration page, select ‘Create Project’. Give an appropriate name for the project and select ‘Create’ option on the page.

Next we have to configure the VSC settings used by TeamCity to obtain the source files for the build. For this select the VCS roots tab and click on ‘Create VCS roots’.
Select the type of source control from the ‘Type of VCS’ dropdown to enter the source control specific configuration entries. Enter the URL, username, password and other details for the sub version and click on Create to update the configuration information.

On the general tab, select ‘Create new build configuration’ to enter details for the build configuration. Enter a name for the build configuration and select VCS settings to continue.
On the next page enter details for the checkout directory and Select ‘Add build Step’.
Select MSBuild as the build runner and enter the name of solution as the Build file path option.

On the build triggering, select ‘Add new trigger’. And select VCS trigger to trigger the build on every check in done to the source safe.

Select Save and you have successfully created an automated build setup for your web application.

ASP.NET dependency injection using Unity Application Block

2011-08-11T19:15:00.000+05:30

ASP.NET was not designed with the concepts of DI and IoC in mind. That makes it very difficult to actually configure a website/ application using ASP.NET to use the concepts of IoC and resolve the dependencies when the pages are requested. An easier way to resolve the dependencies on the page will be using the container and requesting for the resolved types for dependencies. A much better approach is to interpret the page creation implementation code in ASP.NET and resolve the dependencies on the Page from there. In this post I'll show a sample scenario where we'll intercept the page creation logic and resolve the dependencies on the page using Unity container.

The sample used in this article has views that have dependencies on the respective presenters. The presenters will depend on the service abstractions to do their work.

I have the base presenter and view interface declarations as

public abstract class AppPresenter where T : IAppView

{

public T View

{

get

{

if (HttpContext.Current == null) return DependencyInjection.Container.Resolve();

return (T)HttpContext.Current.Handler;

}

public abstract void InitializeViewEvents();

}

public interface IAppView

{

}

For resolving the dependencies on my views, I have created a custom PageHandler implementation which looks like.

public class UnityPageHandlerFactory : PageHandlerFactory

{

public override IHttpHandler GetHandler(HttpContext context, string requestType, string virtualPath, string path)

{

var view = base.GetHandler(context, requestType, virtualPath, path) as Page;

if (view == null) return view;

DependencyInjection.Container.BuildUp(view.GetType(), view);

return view;

}

httpHandlers>

I have created an extension method on the container to register the dependencies while initializing the container

public static class DependencyRegistrations

{

public static void SetupRegistrations(this UnityContainer container)

{

container

.RegisterType<IHomeView, HomeViewNullObject>()

.RegisterType<IHomeService, HomeService>()

.RegisterType<HomePresenter>();

}

Later when the container is initialized you can call the SetupRegistrations methods on the container. container.SetupRegistrations();

A sample view – Presenter implementation can be done like.

public partial class Home : Page, IHomeView

{

private HomePresenter _presenter;

public new event EventHandler OnLoad;

[Dependency]

public HomePresenter Presenter

{

set { _presenter = value; }

}

protected void Page_Load(object sender, EventArgs e)

{

_presenter.InitializeViewEvents();

if (OnLoad != null) OnLoad(this, EventArgs.Empty);

lblHello.Text = _presenter.GetMessage();

}

public class HomePresenter : AppPresenter<IHomeView>

{

private readonly IHomeService _homeService;

public HomePresenter([Dependency] IHomeService homeService)

{

_homeService = homeService;

}

public string GetMessage()

{

return _homeService.GetMessage();

}

public override void InitializeViewEvents()

{

View.OnLoad += new EventHandler(View_OnLoad);

}

Using this kind of an implementation allows you to completely unit test your ASP.NET web application.

[TestMethod]

public void GetMessageShouldRetrieveTheMessageFromTheRegisteredService()

{

var presenter = DependencyInjection.Container.Resolve<HomePresenter>();

Assert.IsFalse(string.IsNullOrEmpty(presenter.GetMessage()));

}

Resharper series - Create Template Methods

2011-07-11T11:28:00.000+05:30

Template method pattern defines the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure. In your code if two or more methods in subclasses perform similar steps in the same order with different logic or steps you can make use of the extract template method refactoring steps to generalize the methods by extracting their steps into methods with identical signatures and pull up these to form the Template Method.

For e.g., the below given code samples simulate the withdrawal functionality on different bank accounts.

public class SavingsAccount

{

private readonly User _user;

private decimal _balance;

public SavingsAccount(User user)

{

_user = user;

}

public string GetUserName()

{

return _user.GetName();

}

public void SetBalance(decimal balance)

{

_balance = balance;

}

public void HasSufficientBalanceForTransfer(decimal amountToWithdraw)

{

if(amountToWithdraw > _balance)

throw new InsufficientBalancesException();

}

public decimal GetServiceChargeForWithdrawal()

{

return 0M;

}

public void WithdrawAmount(decimal amountToWithdraw)

{

_balance -= amountToWithdraw + GetServiceChargeForWithdrawal();

}

public decimal GetBalance()

{

return _balance;

}

public class CurrentAccount

{

private readonly User _user;

private decimal _balance;

public CurrentAccount(User user)

{

_user = user;

}

public string GetUserName()

{

return _user.GetName();

}

public void SetBalance(decimal balance)

{

_balance = balance;

}

public void HasSufficientBalanceForTransfer(decimal amountToWithdraw)

{

if(amountToWithdraw > _balance)

throw new InsufficientBalancesException();

}

public decimal GetServiceChargeForWithdrawal()

{

return 0M;

}

public void WithdrawAmount(decimal amountToWithdraw)

{

_balance -= amountToWithdraw + GetServiceChargeForWithdrawal();

}

public decimal GetBalance()

{

return _balance;

}

The test cases on the current account for the withdrawal function

[TestMethod]

[ExpectedException(typeof(InsufficientBalancesException))]

public void ifUserTriesToWithdrawMoreMoneyThanAvailableBalanceShouldThrowException()

{

var currentAccount = _bank.CreateSavingsAccount(_user);

const decimal balance = 100M;

currentAccount.SetBalance(balance);

const decimal amountToWithdraw = 500M;

currentAccount.HasSufficientBalanceForTransfer(amountToWithdraw);

}

[TestMethod]

public void currentAccountDoesNotDeductServiceChargeOnWithdrawal()

{

var currentAccount = _bank.CreateSavingsAccount(_user);

const decimal balance = 100M;

currentAccount.SetBalance(balance);

var serviceCharge = currentAccount.GetServiceChargeForWithdrawal();

Assert.IsTrue(serviceCharge == 0M);

}

[TestMethod]

public void ifUserTriesToWithdrawAmountAvailableInAccountShouldProccedWithTransaction()

{

var currentAccount = _bank.CreateSavingsAccount(_user);

const decimal balance = 100M;

currentAccount.SetBalance(balance);

const decimal amountToWithdraw = 50M;

currentAccount.WithdrawAmount(amountToWithdraw);

Assert.AreEqual(currentAccount.GetBalance(), 50M);

}

As you can see from the test code, the withdraw functionality follows a series of steps to complete the actual withdrawal of money from the account like checking available balances, calculating the service charge etc. We can try to apply the template method by generalizing these actions and pulling up the template method to an abstract Account class.

First we apply the Extract superclass refactoring to create a superclass that holds the template method.

After applying the refactoring our Current and Savings account classes now looks like.

public class CurrentAccount : Account

{

public CurrentAccount(User user)

{

_user = user;

}

public void HasSufficientBalanceForTransfer(decimal amountToWithdraw)

{

if(amountToWithdraw > _balance)

throw new InsufficientBalancesException();

}

public decimal GetServiceChargeForWithdrawal()

{

return 0M;

}

public void WithdrawAmount(decimal amountToWithdraw)

{

_balance -= amountToWithdraw + GetServiceChargeForWithdrawal();

}

public class SavingsAccount : Account

{

public SavingsAccount(User user)

{

_user = user;

}

public void HasSufficientBalanceForTransfer(decimal amountToWithdraw)

{

if(amountToWithdraw > _balance)

throw new InsufficientBalancesException();

}

public decimal GetServiceChargeForWithdrawal()

{

return 25M;

}

public void WithdrawAmount(decimal amountToWithdraw)

{

_balance -= amountToWithdraw + GetServiceChargeForWithdrawal();

}

Next we apply the pull members up refactoring to pull the generalized methods to the super class and then implement the abstract methods in the respective child classes.

The final output looks like.

public abstract class Account

{

protected User _user;

protected decimal _balance;

public string GetUserName()

{

return _user.GetName();

}

public void SetBalance(decimal balance)

{

_balance = balance;

}

public decimal GetBalance()

{

return _balance;

}

public abstract void HasSufficientBalanceForTransfer(decimal amountToWithdraw);

public abstract decimal GetServiceChargeForWithdrawal();

public void WithdrawAmount(decimal amountToWithdraw)

{

HasSufficientBalanceForTransfer(amountToWithdraw);

var serviceCharge = GetServiceChargeForWithdrawal();

_balance -= amountToWithdraw + serviceCharge;

}

public class CurrentAccount : Account

{

public CurrentAccount(User user)

{

_user = user;

}

public override void HasSufficientBalanceForTransfer(decimal amountToWithdraw)

{

if(amountToWithdraw > _balance)

throw new InsufficientBalancesException();

}

public override decimal GetServiceChargeForWithdrawal()

{

return 0M;

}

public class SavingsAccount : Account

{

public SavingsAccount(User user)

{

_user = user;

}

public override void HasSufficientBalanceForTransfer(decimal amountToWithdraw)

{

if(amountToWithdraw > _balance)

throw new InsufficientBalancesException();

}

public override decimal GetServiceChargeForWithdrawal()

{

return 25M;

}

Resharper series - Extracting factory classes

2011-06-28T19:28:00.000+05:30

You may have come across code that creates a new instance of an object and setting it to a default state before working on it. Sometimes however the creation requirements of this object may grow and clouds the original code that was used to create the object. This is where a Factory class comes into play. For e.g. have a look into the below given test cases and classes.

[TestMethod]

public void ZoomLensesCanHaveMacroModeAlso()

{

const string lensDescription = "Canon EF-S 55-250mm f/4.0-5.6 IS Telephoto Zoom Lens";

var zoomLens = new ZoomLens(lensDescription);

zoomLens.SetCloseupConversion(true);

Assert.IsTrue(zoomLens.HasMacroMode());

}

[TestMethod]

public void WideAngleLensesHaveUltraWideView()

{

const string lensDesription = "Canon EF 35mm f/2 Wide Angle Lens";

var wideAngleLens = new WideAngleLens(lensDesription);

wideAngleLens.SetUltraWideView(true);

Assert.IsTrue(wideAngleLens.HasUltraWideView());

}

The classes used in the sample are as given below.

public class ZoomLens

{

private readonly string _lensDescription;

private bool _closeUpConversionEnabled;

public ZoomLens(string lensDescription)

{

_lensDescription = lensDescription;

_closeUpConversionEnabled = false;

}

public void SetCloseupConversion(bool closeUpConversion)

{

_closeUpConversionEnabled = closeUpConversion;

}

public bool HasMacroMode()

{

return _closeUpConversionEnabled;

}

public class WideAngleLens

{

private readonly string _lensDesription;

private bool _enableUltraWideView;

public WideAngleLens(string lensDesription)

{

_lensDesription = lensDesription;

_enableUltraWideView = false;

}

public void SetUltraWideView(bool enableUltraWideView)

{

_enableUltraWideView = enableUltraWideView;

}

public bool HasUltraWideView()

{

return _enableUltraWideView;

}

As you can see from the classes used in the sample, I can implement a class hierarchy by creating a superclass or an interface for the camera lenses and move the common methods to that type and make the subclasses implement/ inherit the superclass. This provides the situation for usage of a Factory method that makes it easy for programmers to extend the functionality of the framework by introducing polymorphic creations of objects.

First we need to extract all common methods and properties of these classes to a common base class. I have used the Extract Superclass refactoring to create a superclass for the classes in this sample.

After extracting the superclass, we need to create the constructor for the base class with the common properties.

public class CameraLens

{

protected string _lensDesription;

public CameraLens(string lensDescription)

{

_lensDesription = lensDescription;

}

Refactor the base class to use this constructor during object creation.

public WideAngleLens(string lensDesription) : base(lensDesription)

{

_enableUltraWideView = false;

}

Use the Pull members refactoring to move the methods as abstract to the parent class.

Repeat the steps for other inheriting classes also. Compile and run the test cases.

Next use the Extract Method refactoring to move the creation logic to creation methods in the test cases.

After applying the refactoring pattern the code looks like

public void ZoomLensesCanHaveMacroModeAlso()

{

const string lensDescription = "Canon EF-S 55-250mm f/4.0-5.6 IS Telephoto Zoom Lens";

CameraLens zoomLens = CreateCameraLens(lensDescription);

zoomLens.SetCloseupConversion(true);

Assert.IsTrue(zoomLens.HasMacroMode());

}

private static CameraLens CreateCameraLens(string lensDescription)

{

return new ZoomLens(lensDescription);

}

Use the Move to another type refactoring pattern and specify the name of the new class in the type as given below

Make the Create method non- static and use the Extract Interface refactoring as given below.

Now you can use this interface as a dependency for your client classes that needs to create the Camera lenses or change the test cases as given below

private ICameraLensFactory _zoomCameraLensFactory;

[TestInitialize]

public void Initialize()

{

_zoomCameraLensFactory = new ZoomCameraLensFactory();

}

[TestMethod]

public void ZoomLensesCanHaveMacroModeAlso()

{

const string lensDescription = "Canon EF-S 55-250mm f/4.0-5.6 IS Telephoto Zoom Lens";

var zoomLens = _zoomCameraLensFactory.CreateCameraLens(lensDescription);

zoomLens.SetCloseupConversion(true);

Assert.IsTrue(zoomLens.HasMacroMode());

}

Resharper series - Replacing state altering conditionals with state pattern

2011-06-22T20:28:00.000+05:30

If your code has some complex state altering conditional logic, you can refactor that code to use a State pattern implementation by replacing the type code with subclasses. For e.g the Order class given below has the OrderState implemented as a string. The state of the class is changed on some conditional logic.

public class Order

{

private const string NEW = "New";

private const string SUBMITTED = "Submitted";

private const string APPROVED = "Approved";

private const string INPROGRESS = "InProcess";

private const string COMPLETED = "Completed";

private string _orderState;

public Order()

{

_orderState = NEW;

}

public string GetState()

{

return _orderState;

}

public void Submitted()

{

if(_orderState.Equals(NEW)) _orderState = SUBMITTED;

}

public void Approved()

{

if(_orderState.Equals(SUBMITTED)) _orderState = APPROVED;

}

public void Processing()

{

if(_orderState.Equals(APPROVED)) _orderState = INPROGRESS;

}

public void Completed()

{

if(_orderState.Equals(INPROGRESS)) _orderState = COMPLETED;

}

We can refactor this to State pattern to have States implemented as classes.

First step of refactoring involves changing OrderState to a type-safe entity by making it a class rather than having it as string instances. We use the Encapsulate fields refactoring pattern to encapsulate the _orderState variable.

After encapsulating fields for _orderState the code now looks as.

public void Submitted()

{

if(GetOrderState.Equals(NEW)) SetOrderState = SUBMITTED;

}

public void Approved()

{

if(GetOrderState.Equals(SUBMITTED)) SetOrderState = APPROVED;

}

public void Processing()

{

if(GetOrderState.Equals(APPROVED)) SetOrderState = INPROGRESS;

}

public void Completed()

{

if(GetOrderState.Equals(INPROGRESS)) SetOrderState = COMPLETED;

}

Next we create new classes for the OrderState hierarchy and use that instead of the strings an use the Extract superclass pattern to create a superclass OrderState for these classes.

public class NewOrder : OrderState

{

}

Next we need to change the _orderStatus type to OrderState in the Order class from string. First we apply the Extract method pattern to the const string values as given below

After extract method is applied, we need to change the signature of these methods to use the OrderState instead of string. The Change Signature refactoring can be used to do this.

After applying these refactoring the code looks like

private static readonly OrderState NEW = GetNewStatus();

private static OrderState GetNewStatus()

{

return new NewOrder();

}

Do the same for other states also

The final version of our Order class now looks like.

public class Order

{

private static readonly OrderState NEW = GetNewStatus();

private static OrderState GetNewStatus()

{

return new NewOrder();

}

private static readonly OrderState SUBMITTED = GetSubmittedStatus();

private static OrderState GetSubmittedStatus()

{

return new SubmittedOrder();

}

private static readonly OrderState APPROVED = GetApprovedState();

private static OrderState GetApprovedState()

{

return new ApprovedOrder();

}

private static readonly OrderState INPROGRESS = GetInProgressState();

private static OrderState GetInProgressState()

{

return new InProgressOrder();

}

private static readonly OrderState COMPLETED = GetCompletedState();

private static OrderState GetCompletedState()

{

return new CompletedOrder();

}

private OrderState _orderState;

public Order()

{

SetOrderState = NEW;

}

public OrderState GetOrderState

{

get { return _orderState; }

}

public OrderState SetOrderState

{

set { _orderState = value; }

}

public OrderState GetState()

{

return GetOrderState;

}

public void Submitted()

{

if(GetOrderState.Equals(NEW)) SetOrderState = SUBMITTED;

}

public void Approved()

{

if(GetOrderState.Equals(SUBMITTED)) SetOrderState = APPROVED;

}

public void Processing()

{

if(GetOrderState.Equals(APPROVED)) SetOrderState = INPROGRESS;

}

public void Completed()

{

if(GetOrderState.Equals(INPROGRESS)) SetOrderState = COMPLETED;

}

Resharper series - Replacing conditional logic with strategies

2011-06-21T17:02:00.000+05:30

When you have a method with lots of conditional logic (i.e., if statements), you're asking for trouble. Conditional logic is notoriously difficult to manage, and may cause you to create an entire state machine inside a single method. In such a situation, it is better to move each algorithm variation to new classes or to subclasses of the host class. The ideal solution would be to replace these conditional statements with a strategy implementation and delegate the execution to the concrete strategy implementations.

For e.g consider the test code and Calculator implementation given below. The execute methods runs a different algorithm based on the operator chosen.

[TestMethod()]

public void ExecuteMethodShouldCalculateTheSumIfOperationSelectedIsAddition()

{

var calculator = new Calculator();

calculator.SetOperation(Operator.Add);

var result = calculator.Execute(3, 5);

Assert.IsTrue(result == 8);

}

[TestMethod]

public void ExecuteMethodShouldCalculateTheDifferenceIfOperationSelectedIsSubtraction()

{

var calculator = new Calculator();

calculator.SetOperation(Operator.Subtract);

var result = calculator.Execute(3, 5);

Assert.IsTrue(result == -2);

}

[TestMethod]

public void ExecuteMethodShouldCalculateTheMultipledResultIfOperationSelectedIsMultiplication()

{

var calculator = new Calculator();

calculator.SetOperation(Operator.Multiply);

var result = calculator.Execute(3, 5);

Assert.IsTrue(result == 15);

}

[TestMethod]

public void ExecuteMethodShouldCalculateTheDivisionResultIfOperationSelectedIsDivision()

{

var calculator = new Calculator();

calculator.SetOperation(Operator.Divide);

var result = calculator.Execute(15, 5);

Assert.IsTrue(result == 3);

}

public class Calculator

{

private Operator _operator;

public void SetOperation(Operator operation)

{

this._operator = operation;

}

public int Execute(int firstArgument, int secondArgument)

{

if(_operator == Operator.Add)

return firstArgument + secondArgument;

if (_operator == Operator.Subtract)

return firstArgument - secondArgument;

if(_operator == Operator.Multiply)

return firstArgument * secondArgument;

if (_operator == Operator.Divide)

{

if (secondArgument != 0)

return firstArgument / secondArgument;

else

throw new ArgumentException("Divider cannot be zero");

}

return 0;

}

public enum Operator

{

Add,

Subtract,

Multiply,

Divide

}

As a first step to refactoring this code, we use the Extract Method to extract the logic to separate methods as given below.

Once you have completed all the extractions the code now looks like.

public int Execute(int firstArgument, int secondArgument)

{

if(_operator == Operator.Add)

return PerformAdd(firstArgument, secondArgument);

if (_operator == Operator.Subtract)

return PerformSubtraction(firstArgument, secondArgument);

if(_operator == Operator.Multiply)

return PerformMultiplication(firstArgument, secondArgument);

if (_operator == Operator.Divide)

return PerformDivision(firstArgument, secondArgument);

return 0;

}

private int PerformDivision(int firstArgument, int secondArgument)

{

if (secondArgument != 0)

return firstArgument / secondArgument;

else

throw new ArgumentException("Divider cannot be zero");

}

private int PerformMultiplication(int firstArgument, int secondArgument)

{

return firstArgument * secondArgument;

}

private int PerformSubtraction(int firstArgument, int secondArgument)

{

return firstArgument - secondArgument;

}

private int PerformAdd(int firstArgument, int secondArgument)

{

return firstArgument + secondArgument;

}

Next we use the ‘Move to another type’ refactoring to move these methods to separate classes, which we’ll make as concrete strategy implementations later.

After this refactoring your code looks like

public class Calculator

{

private Operator _operator;

public void SetOperation(Operator operation)

{

this._operator = operation;

}

public int Execute(int firstArgument, int secondArgument)

{

if(_operator == Operator.Add)

return AdditionStrategy.PerformAdd(firstArgument, secondArgument);

if (_operator == Operator.Subtract)

return SubtractionStrategy.PerformSubtraction(firstArgument, secondArgument);

if(_operator == Operator.Multiply)

return MultiplicationStrategy.PerformMultiplication(firstArgument, secondArgument);

if (_operator == Operator.Divide)

return DivisionStrategy.PerformDivision(firstArgument, secondArgument);

return 0;

}

Use the ‘Rename’ refactoring to change the name of PerformAdd, PerformSubtraction.. methods to Execute.

After renaming we’ll use the ‘Extract Superclass’ refactoring to create a superclass for these Strategies.

Now create an abstract method Execute with the same signature as in the base classes in the newly created superclass.
Use the resharper intellisense to make the superclass abstract.

Now move to the subclasses and make the execute method override, using the resharper menu.

Finally create a new Factory implementation to create concrete instances for these strategies based on the parameter passed and use this in the Calculator class as given below.

public int Execute(int firstArgument, int secondArgument)

{

var operationStrategyFactory = new OperationStrategyFactory(_operator);

var operationStrategy = operationStrategyFactory.Create();

return operationStrategy.Execute(firstArgument, secondArgument);

}

Resharper series – Replacing constructors with creation methods

2011-06-20T16:55:00.000+05:30

Replacing your constructors with creational methods or static factories helps to reduce cumbersome code with multiple overloaded constructors in the class and clients having confusion which one to invoke and how. The overloaded constructors in your code creates confusion in the mind of a fellow programmer when he wants to create a new instance of the object, the main problem with these constructors are that they cannot be renamed to give a meaningful name. One of the easiest ways to address this problem is to use creation methods or static factories.

Creation methods have better readability and by having meaningful names so that the consumer gets a clear idea of each method and when to use them. Let's see how we can use refactoring to remove overloaded constructors in the code and replace them with creation methods.

As a first step of refactoring find the client code that calls the constructor to create an instance of the type.

[TestMethod]

public void AllDucksCanSwimTest()

{

var pool = new Pool(_ducks);

Assert.IsTrue(pool.CanAllDucksSwim());

}

In the above test method I have a constructor for instantiating the Pool object, which we can refactor to create a new creation method.

Use the Extract method refactoring to create a new static method to get the Pool instance

Now use the Move to another Type refactoring to move the method to the Pool class.

public class Pool

{

private readonly IList<Duck> _ducks;

public Pool(IList<Duck> ducks)

{

_ducks = ducks;

}

public static Pool GetPool(List<Duck> ducks)

{

return new Pool(ducks);

}

public bool CanAllDucksSwim()

{

foreach (var duck in _ducks)

{

duck.Swim();

}

return true;

}

public bool CanAllDucksQuack()

{

foreach (var duck in _ducks)

{

duck.Quack();

}

return true;

}

public class Pool

{

private readonly IList<Duck> _ducks;

Pool(IList<Duck> ducks)

{

_ducks = ducks;

}

public static Pool GetPool(List<Duck> ducks)

{

return new Pool(ducks);

}

public bool CanAllDucksSwim()

{

foreach (var duck in _ducks)

{

duck.Swim();

}

return true;

}

public bool CanAllDucksQuack()

{

foreach (var duck in _ducks)

{

duck.Quack();

}

return true;

}

Compile the code and make sure that it builds successfully.