Sujith's Blog

My most frequently used Gmail shortcuts

skjagini — Sat, 26 Feb 2011 22:13:00 GMT

j: Move down in the list

k: Move up in the list

x: Select/Unselect

* and n : Unselect all

l: label

s: Star

e: Archive

#: Delete

z: Undo

Enter: Enter the selected conversation

c: Compose

r: Reply

a: Reply all

f: Forward

tab and enter: Send

Building applications with WPF, MVVM and Prism(aka CAG)

skjagini — Wed, 02 Feb 2011 05:12:00 GMT

In this article I am going to walk through an application using WPF and Prism (aka composite application guidance, CAG) which simulates engaging a taxi (cab).

The rules are simple, the app would have3 screens

A login screen to authenticate the user
An information screen.
A screen to engage the cab and roam around and calculating the total fare

Metered Rate of Fare

The meter is required to be engaged when a cab is occupied by anyone

$3.00 upon entry

$0.35 for each additional unit

The unit fare is:

one-fifth of a mile, when the cab is traveling at 6 miles an hour or more; or

60 seconds when not in motion or traveling at less than 12 miles per hour.

Night surcharge of $.50 after 8:00 PM & before 6:00 AM

Peak hour Weekday Surcharge of $1.00 Monday - Friday after 4:00 PM & before 8:00 PM

New York State Tax Surcharge of $.50 per ride.

Example:

Friday (2010-10-08)

5:30pm

Start at Lexington Ave & E 57th St

End at Irving Pl & E 15th St

Start = $3.00

Travels 2 miles at less than 6 mph for 15 minutes = $3.50

Travels at more than 12 mph for 5 minutes = $1.75

Peak hour Weekday Surcharge = $1.00 (ride started at 5:30 pm)

New York State Tax Surcharge = $0.50

Before we dive into the app, I would like to give brief description about the framework. If you want to jump on to the source code, scroll all the way to the end of the post.

MVVM

MVVM pattern is in no way related to the usage of PRISM in your application and should be considered if you are using WPF irrespective of PRISM or not.

Lets say you are not familiar with MVVM, your typical UI would involve adding some UI controls like text boxes, a button, double clicking on the button, generating event handler, calling a method from business layer and updating the user interface, it works most of the time for developing small scale applications. The problem with this approach is that there is some amount of code specific to business logic wrapped in UI specific code which is hard to unit test it, mock it and MVVM helps to solve the exact problem.

MVVM stands for Model(M) – View(V) – ViewModel(VM), based on the interactions with in the three parties it should be called VVMM, MVVM sounds more like MVC (Model-View-Controller) so the name.

Why it should be called VVMM: View – View Model - Model

WPF allows to create user interfaces using XAML and MVVM takes it to the next level by allowing complete separation of user interface and business logic.

In WPF each view will have a property, DataContext when set to an instance of a class (which happens to be your view model) provides the data the view is interested in, i.e., view interacts with view model and at the same time view model interacts with view through DataContext. Sujith, if view and view model are interacting directly with each other how does MVVM is helping me separation of concerns? Well, the catch is DataContext is of type Object, since it is of type object view doesn’t know exact type of view model allowing views and views models to be loosely coupled.

View models aggregate data from models (data access layer, services, etc) and make it available for views through properties, methods etc, i.e., View Models interact with Models.

PRISM

Prism is used to build composite applications, the framework is provided by Microsoft Patterns and Practices team and it can be downloaded from codeplex for source code, samples and documentation on msdn. The name composite implies, to compose user interface from different modules without direct dependencies on each other, again allowing loosely coupled development.

Well Sujith, I can already do that with user controls, why shall I learn another framework? That’s correct, you can decouple using user controls, but you still have to manage some amount of coupling, like how to do you communicate between the controls, how do you subscribe/unsubscribe, loading/unloading views dynamically. Prism is not a replacement for user controls, provides the following features which greatly help in designing the composite applications.

Dependency Injection (DI)/ Inversion of Control (IoC)
Modules
Regions
Event Aggregator
Commands

Simply put, MVVM helps building a single view and Prism helps building an application using the views

There are other open source alternatives to Prism, like MVVMLight, Cinch, take a look at them as well.

Lets dig into the source code.

1. Solution

The solution is made of the following projects

Framework: Holds the common functionality in building applications using WPF and Prism
TaxiClient: Start up project, boot strapping and app styling
TaxiCommon: Helps with the business logic
TaxiModules: Holds the meat of the application with views and view models
TaxiTests: To test the application

2. DI / IoC

Dependency Injection (DI) as the name implies refers to injecting dependencies and Inversion of Control (IoC) means the calling code has no direct control on the dependencies, opposite of normal way of programming where dependencies are passed by caller, i.e inversion; aside from some differences in terminology the concept is same in both the cases.

The idea behind DI/IoC pattern is to reduce the amount of direct coupling between different components of the application, the higher the dependency the more tightly coupled the application resulting in code which is hard to modify, unit test and mock.

Initializing Dependency Injection through BootStrapper

TaxiClient is the starting project of the solution and App (App.xaml) is the starting class that gets called when you run the application.

From the App’s OnStartup method we will invoke BootStrapper.

namespace TaxiClient

    /// <summary>

    /// Interaction logic for App.xaml

    /// </summary>

    public partial class App : Application

        protected override void OnStartup(StartupEventArgs e)

            base.OnStartup(e);

            (new BootStrapper()).Run();

BootStrapper is your contact point for initializing the application including dependency injection, creating Shell and other frameworks. We are going to use Unity for DI and there are lot of open source DI frameworks like Spring.Net, StructureMap etc with different feature set and you can choose a framework based on your preferences. Note that Prism comes with in built support for Unity, for example we are deriving from UnityBootStrapper in our case and for any other DI framework you have to extend the Prism appropriately

namespace TaxiClient

    public class BootStrapper: UnityBootstrapper

        protected override IModuleCatalog  CreateModuleCatalog()

            return new ConfigurationModuleCatalog();

        protected override DependencyObject CreateShell()

            Framework.FrameworkBootStrapper.Run(Container, Application.Current.Dispatcher);

            Shell shell = new Shell();

            shell.ResizeMode = ResizeMode.NoResize;

            shell.Show();

            return shell;

Lets take a look into FrameworkBootStrapper to check out how to register with unity container.

namespace Framework

    public class FrameworkBootStrapper

        public static void Run(IUnityContainer container, Dispatcher dispatcher)

            UIDispatcher uiDispatcher = new UIDispatcher(dispatcher);

            container.RegisterInstance<IDispatcherService>(uiDispatcher);

            container.RegisterType<IInjectSingleViewService, InjectSingleViewService>(

                new ContainerControlledLifetimeManager());

            . . .

In the above code we are registering two components with unity container. You shall observe that we are following two different approaches, RegisterInstance and RegisterType. With RegisterInstance we are registering an existing instance and the same instance will be returned for every request made for IDispatcherService and with RegisterType we are requesting unity container to create an instance for us when required, i.e., when I request for an instance for IInjectSingleViewService, unity will create/return an instance of InjectSingleViewService class and with RegisterType we can configure the life time of the instance being created. With ContaienrControllerLifetimeManager, the unity container caches the instance and reuses for any subsequent requests, without recreating a new instance.

Lets take a look into FareViewModel.cs and it’s constructor. The constructor takes one parameter IEventAggregator and if you try to find all references in your solution for IEventAggregator, you will not find a single location where an instance of EventAggregator is passed directly to the constructor. The compiler still finds an instance and works fine because Prism is already configured when used with Unity container to return an instance of EventAggregator when requested for IEventAggregator and in this particular case it is called constructor injection.

public class FareViewModel:ObservableBase, IDataErrorInfo

...

        private IEventAggregator _eventAggregator;

        public FareViewModel(IEventAggregator eventAggregator)

            _eventAggregator = eventAggregator;

            InitializePropertyNames();

            InitializeModel();

            PropertyChanged += OnPropertyChanged;

...

3. Shell

Shells are very similar in operation to Master Pages in asp.net or MDI in Windows Forms. And shells contain regions which display the views, you can have as many regions as you wish in a given view. You can also nest regions. i.e, one region can load a view which in itself may contain other regions.

We have to create a shell at the start of the application and are doing it by overriding CreateShell method from BootStrapper

From the following Shell.xaml you shall notice that we have two content controls with Region names as ‘MenuRegion’ and ‘MainRegion’. The idea here is that you can inject any user controls into the regions dynamically, i.e., a Menu User Control for MenuRegion and based on the user action you can load appropriate view into MainRegion.

<Window x:Class="TaxiClient.Shell"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:Regions="clr-namespace:Microsoft.Practices.Prism.Regions;assembly=Microsoft.Practices.Prism"

        Title="Taxi" Height="370" Width="800">

    <Grid Margin="2">

        <ContentControl

            Regions:RegionManager.RegionName="MenuRegion"

            HorizontalAlignment="Stretch"

            VerticalAlignment="Stretch"

            HorizontalContentAlignment="Stretch"

            VerticalContentAlignment="Stretch" />

        <ContentControl Grid.Row="1"

            Regions:RegionManager.RegionName="MainRegion"

            HorizontalAlignment="Stretch"

            VerticalAlignment="Stretch"

            HorizontalContentAlignment="Stretch"

            VerticalContentAlignment="Stretch" />

        <!--<Border Grid.ColumnSpan="2" BorderThickness="2" CornerRadius="3" BorderBrush="LightBlue" />-->

    </Grid>

</Window>

4. Modules

Prism provides the ability to build composite applications and modules play an important role in it.

For example if you are building a Mortgage Loan Processor application with 3 components, i.e. customer’s credit history, existing mortgages, new home/loan information; and consider that the customer’s credit history component involves gathering data about his/her address, background information, job details etc. The idea here using Prism modules is to separate the implementation of these 3 components into their own visual studio projects allowing to build components with no dependency on each other and independently. If we need to add another component to the application, the component can be developed by in house team or some other team in the organization by starting with a new Visual Studio project and adding to the solution at the run time with very little knowledge about the application.

Prism modules are defined by implementing the IModule interface and each visual studio project to be considered as a module should implement the IModule interface. From the BootStrapper.cs you shall observe that we are overriding the method by returning a ConfiguratingModuleCatalog which returns the modules that are registered for the application using the app.config file and you can also add module using code.

Lets take a look into configuration file.

<?xml version="1.0"?>

<configuration>

  <configSections>

    <section name="modules"

             type="Microsoft.Practices.Prism.Modularity.ModulesConfigurationSection, Microsoft.Practices.Prism"/>

  </configSections>

  <modules>

    <module assemblyFile="TaxiModules.dll" moduleType="TaxiModules.ModuleInitializer, TaxiModules"

            moduleName="TaxiModules"/>

  </modules>

</configuration>

Here we are adding TaxiModules project to our solution and TaxiModules.ModuleInitializer implements IModule interface

5. Module Mapper

With Prism modules you can dynamically add or remove modules, apart from that Prism also provides API to control adding/removing the views from a region.

Taxi Information Screen:

Engage the Taxi Screen:

The sample application has two screens, ‘Taxi Information’ and ‘Engage the Taxi’ and they both reside in same module, TaxiModules. ‘Engage the Taxi’ is again made of two user controls, FareView on the left and TotalView on the right. We have created a Shell with two regions, MenuRegion and MainRegion with MenuView loaded into MenuRegion. We can create a wrapper user control called EngageTheTaxiView made of FareView and TotalView and load either TaxiInfo or EngageTheTaxi into MainRegion based on the user action. Though it will work it tightly binds the user controls and for every combination of user controls, we need to create a dummy wrapper control to contain them. Instead we can apply the principles we learned so far from Shell/regions and introduce another template (LeftAndRightRegionView.xaml) made of two regions Region1 (left) and Region2 (right) and load FareView and TotalView dynamically.

To help with loading of the views dynamically I have introduce an helper an interface, IInjectSingleViewService, idea suggested by Mike Taulty, a must read blog for .Net developers.

using System;

using System.Collections.Generic;

using System.ComponentModel;

namespace Framework.PresentationUtility.Navigation

    public interface IInjectSingleViewService : INotifyPropertyChanged

        IEnumerable<CommandViewDefinition> Commands { get; }

        IEnumerable<ModuleViewDefinition> Modules { get; }

        void RegisterViewForRegion(string commandName, string viewName, string regionName, Type viewType);

        void ClearViewFromRegion(string viewName, string regionName);

        void RegisterModule(string moduleName, IList<ModuleMapper> moduleMappers);

The Interface declares three methods to work with views:

RegisterViewForRegion: Registers a view with a particular region. You can register multiple views and their regions under one command. When this particular command is invoked all the views registered under it will be loaded into their regions.
ClearViewFromRegion: To unload a specific view from a region.
RegisterModule: The idea is when a command is invoked you can load the UI with set of controls in their default position and based on the user interaction, you can load different contols in to different regions on the fly. And it is supported ModuleViewDefinition and ModuleMappers as shown below.

namespace Framework.PresentationUtility.Navigation

    public class ModuleViewDefinition

        public string ModuleName { get; set; }

        public IList<ModuleMapper> ModuleMappers;

        public ICommand Command { get; set; }

    public class ModuleMapper

        public string ViewName { get; set; }

        public string RegionName { get; set; }

        public Type ViewType { get; set; }

6. Event Aggregator

Prism event aggregator enables messaging between components as in Observable pattern, Notifier notifies the Observer which receives notification it is interested in.

When it comes to Observable pattern, Observer has to unsubscribes for notifications when it no longer interested in notifications, which allows the Notifier to remove the Observer’s reference from it’s local cache. Though .Net has managed garbage collection it cannot remove inactive the instances referenced by an active instance resulting in memory leak, keeping the Observers in memory as long as Notifier stays in memory.

Developers have to be very careful to unsubscribe when necessary and it often gets overlooked, to overcome these problems Prism Event Aggregator uses weak references to cache the reference (Observer in this case) and releases the reference (memory) once the instance goes out of scope.

Using event aggregator is very simple, declare a generic type of CompositePresenationEvent by inheriting from it.

using Microsoft.Practices.Prism.Events;

using TaxiCommon.BAO;

namespace TaxiCommon.CompositeEvents

    public class TaxiOnMoveEvent:CompositePresentationEvent<TaxiOnMove>

TaxiOnMove.cs includes the properties which we want to exchange between the parties, FareView and TotalView.

using System;

namespace TaxiCommon.BAO

    public class TaxiOnMove

        public TimeSpan MinutesAtTweleveMPH { get; set; }

        public double MilesAtSixMPH { get; set; }

Lets take a look into FareViewodel (Notifier) and how it raises the event. Here we are raising the event by getting the event through GetEvent<..>() and publishing it with the payload

private void OnAddMinutes(object obj)

     TaxiOnMove payload = new TaxiOnMove();

     if(MilesAtSixMPH != null) payload.MilesAtSixMPH = MilesAtSixMPH.Value;

     if(MinutesAtTweleveMPH != null) payload.MinutesAtTweleveMPH =

         new TimeSpan(0,0,MinutesAtTweleveMPH.Value,0);

     _eventAggregator.GetEvent<TaxiOnMoveEvent>().Publish(payload);

     ResetMinutesAndMiles();

And TotalViewModel(Observer) subscribes to notifications by getting the event through GetEvent<..>()

namespace TaxiModules.ViewModels

    public class TotalViewModel:ObservableBase

        ....

        private IEventAggregator _eventAggregator;

        public TotalViewModel(IEventAggregator eventAggregator)

            _eventAggregator = eventAggregator;

...

        private void SubscribeToEvents()

            _eventAggregator.GetEvent<TaxiStartedEvent>()

                .Subscribe(OnTaxiStarted, ThreadOption.UIThread,false,(filter) => true);

            _eventAggregator.GetEvent<TaxiOnMoveEvent>()

                .Subscribe(OnTaxiMove, ThreadOption.UIThread, false, (filter) => true);

            _eventAggregator.GetEvent<TaxiResetEvent>()

                .Subscribe(OnTaxiReset, ThreadOption.UIThread, false, (filter) => true);

...

        private void OnTaxiMove(TaxiOnMove taxiOnMove)

            OnMoveFare fare = new OnMoveFare(taxiOnMove);

            Fares.Add(fare);

            SetTotalFare(new []{fare});

        ....

7. MVVM through example

In this section we are going to look into MVVM implementation through example. I have all the modules declared in a single project, TaxiModules, again it is not necessary to have them into one project.

Once the user logs into the application, will be greeted with the ‘Engage the Taxi’ screen which is made of two user controls, FareView.xaml and TotalView.Xaml. As you can see from the solution explorer, each of them have their own code behind files and ViewModel classes, FareViewMode.cs, TotalViewModel.cs

Lets take a look in to the FareView and how it interacts with FareViewModel using MVVM implementation. FareView.xaml acts as a view and FareViewMode.cs is it’s view model.

The FareView code behind class

namespace TaxiModules.Views

    /// <summary>

    /// Interaction logic for FareView.xaml

    /// </summary>

    public partial class FareView : UserControl

        public FareView(FareViewModel viewModel)

            InitializeComponent();

            this.Loaded += (s, e) => { this.DataContext = viewModel; };

The FareView is bound to FareViewModel through the data context and you shall observe that DataContext is of type Object, i.e. the FareView doesn’t really know the type of ViewModel (FareViewModel). This helps separation of View and ViewModel as View and ViewModel are independent of each other, you can bind FareView to FareViewModel2 as well and the application compiles just fine.

Lets take a look into FareView xaml file

 
<UserControl x:Class="TaxiModules.Views.FareView"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:Toolkit="clr-namespace:Microsoft.Windows.Controls;assembly=WPFToolkit"

    xmlns:Commands="clr-namespace:Microsoft.Practices.Prism.Commands;assembly=Microsoft.Practices.Prism">

    <Grid Margin="10" >

        ....

        <Border Style="{DynamicResource innerBorder}"

                Grid.Row="0" Grid.Column="0" Grid.RowSpan="11" Grid.ColumnSpan="2" Panel.ZIndex="1"/>

        <Label Grid.Row="0" Content="Engage the Taxi" Style="{DynamicResource innerHeader}"/>

        <Label Grid.Row="1" Content="Select the State"/>

        <ComboBox Grid.Row="1" Grid.Column="1" ItemsSource="{Binding States}" Height="auto">

            <ComboBox.ItemTemplate>

                <DataTemplate>

                    <TextBlock Text="{Binding Name}"/>

                </DataTemplate>

            </ComboBox.ItemTemplate>

            <ComboBox.SelectedItem>

                <Binding Path="SelectedState" Mode="TwoWay"/>

            </ComboBox.SelectedItem>

        </ComboBox>

        <Label Grid.Row="2" Content="Select the Date of Entry"/>

        <Toolkit:DatePicker Grid.Row="2" Grid.Column="1"

                            SelectedDate="{Binding DateOfEntry, ValidatesOnDataErrors=true}" />

        <Label Grid.Row="3" Content="Enter time 24hr format"/>

        <TextBox Grid.Row="3" Grid.Column="1" Text="{Binding TimeOfEntry, TargetNullValue=''}"/>

        <Button Grid.Row="4" Grid.Column="1" Content="Start the Meter"

                Commands:Click.Command="{Binding StartMeterCommand}" />

        <Label Grid.Row="5" Content="Run the Taxi" Style="{DynamicResource innerHeader}"/>

        <Label Grid.Row="6" Content="Number of Miles &lt;@6mph"/>

        <TextBox Grid.Row="6" Grid.Column="1"

                 Text="{Binding MilesAtSixMPH, TargetNullValue='', ValidatesOnDataErrors=true}"/>

        <Label Grid.Row="7" Content="Number of Minutes @12mph"/>

        <TextBox Grid.Row="7" Grid.Column="1" Text="{Binding MinutesAtTweleveMPH, TargetNullValue=''}"/>

        <Button Grid.Row="8" Grid.Column="1" Content="Add Minutes and Miles "

                Commands:Click.Command="{Binding AddMinutesCommand}"/>

        <Label Grid.Row="9" Content="Other Operations" Style="{DynamicResource innerHeader}"/>

        <Button Grid.Row="10" Grid.Column="1" Content="Reset the Meter"

                Commands:Click.Command="{Binding ResetCommand}"/>

    </Grid>

</UserControl>

The highlighted code from the above code shows data binding, for example ComboBox which displays list of states has it’s ItemsSource bound to States property, with DataTemplate bound to Name and SelectedItem to SelectedState. You might be wondering what are all these properties and how it is able to bind to them. The answer lies in data context, i.e., when you bound a control, WPF looks for data context on the root object (Grid in this case) and if it can’t find data context it will look into root’s root, i.e. FareView UserControl and it is bound to FareViewModel. Each of those properties have be declared on the ViewModel for the View to bind correctly.

To put simply, View is bound to ViewModel through data context of type object and every control that is bound on the View actually binds to the public property on the ViewModel.

Lets look into the ViewModel code (the following code is not an exact copy of FareViewMode.cs, pasted relevant code for this section)

namespace TaxiModules.ViewModels

    public class FareViewModel:ObservableBase, IDataErrorInfo

        public List<USState> States { get { return USStates.StateList; } }

        public USState SelectedState

            get { return _selectedState; }

set

                _selectedState = value;

                RaisePropertyChanged(_selectedStatePropertyName);

        public DateTime? DateOfEntry

            get { return _dateOfEntry; }

set

                _dateOfEntry = value;

                RaisePropertyChanged(_dateOfEntryPropertyName);

        public TimeSpan? TimeOfEntry

            get { return _timeOfEntry; }

set

                _timeOfEntry = value;

                RaisePropertyChanged(_timeOfEntryPropertyName);

        public double? MilesAtSixMPH

            get { return _milesAtSixMPH; }

set

                _milesAtSixMPH = value;

                RaisePropertyChanged(_distanceAtSixMPHPropertyName);

        public int? MinutesAtTweleveMPH

            get { return _minutesAtTweleveMPH; }

set

                _minutesAtTweleveMPH = value;

                RaisePropertyChanged(_minutesAtTweleveMPHPropertyName);

        public ICommand StartMeterCommand

get

                if(_startMeterCommand == null)

                    _startMeterCommand = new DelegateCommand<object>(OnStartMeter, CanStartMeter);

                return _startMeterCommand;

        public ICommand AddMinutesCommand

get

                if(_addMinutesCommand == null)

                    _addMinutesCommand = new DelegateCommand<object>(OnAddMinutes, CanAddMinutes);

                return _addMinutesCommand;

        public ICommand ResetCommand

get

                if(_resetCommand == null)

                    _resetCommand = new DelegateCommand<object>(OnResetCommand);

                return _resetCommand;

private void OnStartMeter(object obj)

    _eventAggregator.GetEvent<TaxiStartedEvent>().Publish(

        new TaxiStarted()

            EngagedOn = DateOfEntry.Value.Date + TimeOfEntry.Value,

            EngagedState = SelectedState.Value

});

    _isMeterStarted = true;

    OnPropertyChanged(this,null);

And views communicate user actions like button clicks, tree view item selections, etc using commands. When user clicks on ‘Start the Meter’ button it invokes the method StartMeterCommand, which calls the method OnStartMeter which publishes the event to TotalViewModel using event aggregator and TaxiStartedEvent.

namespace TaxiModules.ViewModels

    public class TotalViewModel:ObservableBase

...

        private IEventAggregator _eventAggregator;

        public TotalViewModel(IEventAggregator eventAggregator)

            _eventAggregator = eventAggregator;

            InitializePropertyNames();

            InitializeModel();

            SubscribeToEvents();

        public decimal? TotalFare

            get { return _totalFare; }

set

                _totalFare = value;

                RaisePropertyChanged(_totalFarePropertyName);

        ....

        private void SubscribeToEvents()

            _eventAggregator.GetEvent<TaxiStartedEvent>().Subscribe(OnTaxiStarted, ThreadOption.UIThread,false,(filter) => true);

            _eventAggregator.GetEvent<TaxiOnMoveEvent>().Subscribe(OnTaxiMove, ThreadOption.UIThread, false, (filter) => true);

            _eventAggregator.GetEvent<TaxiResetEvent>().Subscribe(OnTaxiReset, ThreadOption.UIThread, false, (filter) => true);

        private void OnTaxiStarted(TaxiStarted taxiStarted)

            Fares.Add(new EntryFare());

            Fares.Add(new StateTaxFare(taxiStarted));

            Fares.Add(new NightSurchargeFare(taxiStarted));

            Fares.Add(new PeakHourWeekdayFare(taxiStarted));

            SetTotalFare(Fares);

        private void SetTotalFare(IEnumerable<IFare> fares)

            TotalFare = (_totalFare ?? 0) + TaxiFareHelper.GetTotalFare(fares);

        ....

TotalViewModel subscribes to events, TaxiStartedEvent and rest. When TaxiStartedEvent gets invoked it calls the OnTaxiStarted method which sets the total fare which includes entry fee, state tax, nightly surcharge, peak hour weekday fare.

Note that TotalViewModel derives from ObservableBase which implements the method RaisePropertyChanged which we are invoking in Set of TotalFare property, i.e, once we update the TotalFare property it raises an the event that allows the TotalFare text box to fetch the new value through the data context. ViewModel is communicating with View through data context and it has no knowledge about View, helping in loose coupling of ViewModel and View.

I have attached the source code (.Net 4.0, Prism 4.0, VS 2010) , download and play with it and don’t forget to leave your comments.

For my reference: Design Patterns and Guidelines

skjagini — Fri, 14 Jan 2011 18:39:00 GMT

This document is for my own reference, a collection of resources I have gathered trying to understand design patterns and guidelines.

Find the attachment as .docx

Building applications with WCF - Part 1 of n

skjagini — Sun, 09 Jan 2011 22:30:00 GMT

I am going to write series of articles using Windows Communication Framework (WCF) to develop client and server applications and this is the first part of that series.

What is WCF

As Juwal puts in his Programming WCF book, WCF provides an SDK for developing and deploying services on Windows, provides runtime environment to expose CLR types as services and consume services as CLR types. Building services with WCF is incredibly easy and it’s implementation provides a set of industry standards and off the shelf plumbing including service hosting, instance management, reliability, transaction management, security etc such that it greatly increases productivity

Scenario:

Lets consider a typical bank customer trying to create an account, deposit amount and transfer funds between accounts, i.e. checking and savings. To make it interesting, we are going to divide the functionality into multiple services and each of them working with database directly. We will run test cases with and without transactional support across services.

In this post we will build contracts, services, data access layer, unit tests to verify end to end communication etc, nothing big stuff here and we dig into other features of the WCF in subsequent posts with incremental changes.

In any distributed architecture we have two pieces i.e. services and clients. Services as the name implies provide functionality to execute various pieces of business logic on the server, and clients providing interaction to the end user. Services can be built with Web Services or with WCF. Service built on WCF have the advantage of binding independent, i.e. can run against TCP and HTTP protocol without any significant changes to the code.

Solution

Services
- Profile: For creating a new bank customer, getting details about existing customer
  - ProfileContract
  - ProfileService
- Checking Account: To get checking account balance, deposit or withdraw amount
  - CheckingAccountContract
  - CheckingAccountService
- Savings Account: To get savings account balance, deposit or withdraw amount
  - SavingsAccountContract
  - SavingsAccountService
ServiceHost: To host services, i.e. running the services at particular address, binding and contract where client can connect to
Client: Helps end user to use services like creating account and amount transfer between the accounts
BankDAL: Data access layer to work with database

BankDAL

It’s no brainer not to use an ORM as many matured products are available currently in market including Linq2Sql, Entity Framework (EF), LLblGenPro etc. For this exercise I am going to use Entity Framework 4.0, CTP 5 with code first approach.

There are two approaches when working with data, data driven and code driven. In data driven we start by designing tables and their constrains in database and generate entities in code while in code driven (code first) approach entities are defined in code and the metadata generated from the entities is used by the EF to create tables and table constrains.

In previous versions the entity classes had to derive from EF specific base classes. In EF 4 it is not required to derive from any EF classes, the entities are not only persistence ignorant but also enable full test driven development using mock frameworks.

Application consists of 3 entities, Customer entity which contains Customer details; CheckingAccount and SavingsAccount to hold the respective account balance. We could have introduced an Account base class for CheckingAccount and SavingsAccount which is certainly possible with EF mappings but to keep it simple we are just going to follow 1 –1 mapping between entity and table mappings.

Lets start out by defining a class called Customer which will be mapped to Customer table, observe that the class is simply a plain old clr object (POCO) and has no reference to EF at all.

using System;

namespace BankDAL.Model

    public class Customer

        public int Id { get; set; }

        public string FullName { get; set; }

        public string Address { get; set; }

        public DateTime DateOfBirth { get; set; }

In order to inform EF about the Customer entity we have to define a database context with properties of type DbSet<> for every POCO which needs to be mapped to a table in database. EF uses convention over configuration to generate the metadata resulting in much less configuration.

using System.Data.Entity;

namespace BankDAL.Model

    public class BankDbContext: DbContext

        public DbSet<Customer> Customers { get; set; }

Entity constrains can be defined through attributes on Customer class or using fluent syntax (no need to muscle with xml files), CustomerConfiguration class. By defining constrains in a separate class we can maintain clean POCOs without corrupting entity classes with database specific information.

using System;

using System.Data.Entity.ModelConfiguration;

namespace BankDAL.Model

    public class CustomerConfiguration: EntityTypeConfiguration<Customer>

        public CustomerConfiguration()

            Initialize();

        private void Initialize()

            //Setting the Primary Key

            this.HasKey(e => e.Id);

            //Setting required fields

            this.HasRequired(e => e.FullName);

            this.HasRequired(e => e.Address);

            //Todo: Can't create required constraint as DateOfBirth is not reference type, research it

            //this.HasRequired(e => e.DateOfBirth);

Any queries executed against Customers property in BankDbContext are executed against Cusomers table. By convention EF looks for connection string with key of BankDbContext when working with the context.

We are going to define a helper class to work with Customer entity with methods for querying, adding new entity etc and these are known as repository classes, i.e., CustomerRepository

using System;

using System.Data.Entity;

using System.Linq;

using BankDAL.Model;

namespace BankDAL.Repositories

    public class CustomerRepository

        private readonly IDbSet<Customer> _customers;

        public CustomerRepository(BankDbContext bankDbContext)

            if (bankDbContext == null) throw new ArgumentNullException();

            _customers = bankDbContext.Customers;

        public IQueryable<Customer> Query()

            return _customers;

        public void Add(Customer customer)

            _customers.Add(customer);

From the above code it is observable that the Query methods returns customers as IQueryable i.e. customers are retrieved only when actually used i.e. iterated. Returning as IQueryable also allows to execute filtering and joining statements from business logic  using lamba

expressions without cluttering the data access layer with tens of methods.

Our CheckingAccountRepository and SavingsAccountRepository look very similar to each other

using System;

using System.Data.Entity;

using System.Linq;

using BankDAL.Model;

namespace BankDAL.Repositories

    public class CheckingAccountRepository

        private readonly IDbSet<CheckingAccount> _checkingAccounts;

        public CheckingAccountRepository(BankDbContext bankDbContext)

            if (bankDbContext == null) throw new ArgumentNullException();

           _checkingAccounts = bankDbContext.CheckingAccounts;

        public IQueryable<CheckingAccount> Query()

            return _checkingAccounts;

        public void Add(CheckingAccount account)

            _checkingAccounts.Add(account);

        public IQueryable<CheckingAccount> GetAccount(int customerId)

            return (from act in _checkingAccounts

                    where act.CustomerId == customerId

                    select act);

The repository classes look very similar to each other for Query and Add methods, with the help of C# generics and implementing repository pattern (Martin Fowler) we can reduce the repeated code. Jarod from ElegantCode has posted an article on how to use repository pattern with EF which we will implement in the subsequent articles along with WCF Unity life time managers by Drew

Contracts

It is very easy to follow contract first approach with WCF, define the interface and append ServiceContract, OperationContract attributes.

IProfile contract exposes functionality for creating customer and getting customer details.

using System;

using System.ServiceModel;

using BankDAL.Model;

namespace ProfileContract

    [ServiceContract]

    public interface IProfile

        [OperationContract]

        Customer CreateCustomer(string customerName, string address, DateTime dateOfBirth);

        [OperationContract]

        Customer GetCustomer(int id);

ICheckingAccount contract exposes functionality for working with checking account, i.e., getting balance, deposit and withdraw of amount.

ISavingsAccount contract looks the same as checking account.

using System.ServiceModel;

namespace CheckingAccountContract

    [ServiceContract]

    public interface ICheckingAccount

        [OperationContract]

        decimal? GetCheckingAccountBalance(int customerId);

        [OperationContract]

        void DepositAmount(int customerId,decimal amount);

        [OperationContract]

        void WithdrawAmount(int customerId, decimal amount);

Services

Having covered the data access layer and contracts so far and here comes the core of the business logic, i.e. services.

ProfileService implements the IProfile contract for creating customer and getting customer detail using CustomerRepository.

using System;

using System.Linq;

using System.ServiceModel;

using BankDAL;

using BankDAL.Model;

using BankDAL.Repositories;

using ProfileContract;

namespace ProfileService

    [ServiceBehavior(IncludeExceptionDetailInFaults = true)]

    public class Profile: IProfile

        public Customer CreateAccount(

            string customerName, string address, DateTime dateOfBirth)

            Customer cust =

                new Customer

                { FullName = customerName, Address = address, DateOfBirth = dateOfBirth };

            using (var bankDbContext = new BankDbContext())

                new CustomerRepository(bankDbContext).Add(cust);

                bankDbContext.SaveChanges();

            return cust;

        public Customer CreateCustomer(string customerName, string address, DateTime dateOfBirth)

            return CreateAccount(customerName, address, dateOfBirth);

        public Customer GetCustomer(int id)

            return new CustomerRepository(new BankDbContext()).Query()

                .Where(i => i.Id == id).FirstOrDefault();

From the above code you shall observe that we are calling bankDBContext’s SaveChanges method and there is no save method specific to customer entity because EF manages all the changes centralized at the context level and all the pending changes so far are submitted in a batch and it is represented as Unit of Work.

Similarly Checking service implements ICheckingAccount contract using CheckingAccountRepository, notice that we are throwing overdraft exception if the balance falls by zero. WCF has it’s own way of raising exceptions using fault contracts which will be explained in the subsequent articles.

SavingsAccountService is similar to CheckingAccountService.

using System;

using System.Linq;

using System.ServiceModel;

using BankDAL.Model;

using BankDAL.Repositories;

using CheckingAccountContract;

namespace CheckingAccountService

    [ServiceBehavior(IncludeExceptionDetailInFaults = true)]

    public class Checking:ICheckingAccount

        public decimal? GetCheckingAccountBalance(int customerId)

            using (var bankDbContext = new BankDbContext())

                CheckingAccount account =

                    (new CheckingAccountRepository(bankDbContext)

                    .GetAccount(customerId)).FirstOrDefault();

                if (account != null)

                    return account.Balance;

                return null;

        public void DepositAmount(int customerId, decimal amount)

            using(var bankDbContext = new BankDbContext())

                var checkingAccountRepository =

                    new CheckingAccountRepository(bankDbContext);

                CheckingAccount account =

                    (checkingAccountRepository.GetAccount(customerId))

                    .FirstOrDefault();

                if (account == null)

                    account = new CheckingAccount() { CustomerId = customerId };

                    checkingAccountRepository.Add(account);

                account.Balance = account.Balance + amount;

                if (account.Balance < 0)

                    throw new ApplicationException("Overdraft not accepted");

                bankDbContext.SaveChanges();

        public void WithdrawAmount(int customerId, decimal amount)

           DepositAmount(customerId, -1*amount);

BankServiceHost

The host acts as a glue binding contracts with it’s services, exposing the endpoints. The services can be exposed either through the code or

configuration file,  configuration file is preferred as it allows run time changes to service behavior even after deployment.

We have 3 services and for each of the service you need to define name (the class that implements the service with fully qualified namespace)

and endpoint known as ABC, i.e. address, binding and contract. We are using netTcpBinding and have defined the base address

with for each of the contracts

<system.serviceModel>

  <services>

    <service name="ProfileService.Profile">

      <endpoint binding="netTcpBinding" contract="ProfileContract.IProfile"/>

      <host>

        <baseAddresses>

          <add baseAddress="net.tcp://localhost:1000/Profile"/>

        </baseAddresses>

      </host>

    </service>

    <service name="CheckingAccountService.Checking">

      <endpoint binding="netTcpBinding"

                contract="CheckingAccountContract.ICheckingAccount"/>

      <host>

        <baseAddresses>

          <add baseAddress="net.tcp://localhost:1000/Checking"/>

        </baseAddresses>

      </host>

    </service>

    <service name="SavingsAccountService.Savings">

      <endpoint binding="netTcpBinding"

                contract="SavingsAccountContract.ISavingsAccount"/>

      <host>

        <baseAddresses>

          <add baseAddress="net.tcp://localhost:1000/Savings"/>

        </baseAddresses>

      </host>

    </service>

  </services>

</system.serviceModel>

Have to open the services by creating service host which will handle the incoming requests from clients.

using System;

namespace ServiceHost

    class Program

        static void Main(string[] args)

            CreateHosts();

            Console.ReadLine();

        private static void CreateHosts()

            CreateHost(typeof(ProfileService.Profile),"Profile Service");

            CreateHost(typeof(SavingsAccountService.Savings),

                "Savings Account Service");

            CreateHost(typeof(CheckingAccountService.Checking),

                "Checking Account Service");

        private static void CreateHost(Type type, string hostDescription)

            System.ServiceModel.ServiceHost host =

                new System.ServiceModel.ServiceHost(type);

            host.Open();

            if (host.ChannelDispatchers != null

                && host.ChannelDispatchers.Count != 0

                && host.ChannelDispatchers[0].Listener != null)

                Console.WriteLine("Started: " + host.ChannelDispatchers[0].Listener.Uri);

            else

                Console.WriteLine("Failed to start:" + hostDescription);

BankClient

The client has no knowledge about service business logic other than the functionality it exposes through the contract, end points and a proxy

to work against. The endpoint data and server proxy can be generated by right clicking on the project reference and choosing

‘Add Service Reference’ and entering the service end point address. Or if you have access to source, you can manually reference

contract dlls and update clients configuration file to point to the service end point if the server and client happens to be being built

using .Net framework. One of the pros with the manual approach is you don’t have to work against messy code generated files.

        <system.serviceModel>

          <client>

            <endpoint name="tcpProfile" address="net.tcp://localhost:1000/Profile" binding="netTcpBinding" contract="ProfileContract.IProfile"/>

            <endpoint name="tcpCheckingAccount" address="net.tcp://localhost:1000/Checking" binding="netTcpBinding" contract="CheckingAccountContract.ICheckingAccount"/>

            <endpoint name="tcpSavingsAccount" address="net.tcp://localhost:1000/Savings" binding="netTcpBinding" contract="SavingsAccountContract.ISavingsAccount"/>

          </client>

        </system.serviceModel>

The client uses a façade to connect to the services

using System.ServiceModel;

using CheckingAccountContract;

using ProfileContract;

using SavingsAccountContract;

namespace Client

    public class ProxyFacade

        public static IProfile ProfileProxy()

            return

                (new ChannelFactory<IProfile>("tcpProfile")).CreateChannel();

        public static ICheckingAccount CheckingAccountProxy()

            return (new ChannelFactory<ICheckingAccount>("tcpCheckingAccount"))

                .CreateChannel();

        public static ISavingsAccount SavingsAccountProxy()

            return (new ChannelFactory<ISavingsAccount>("tcpSavingsAccount"))

                .CreateChannel();

With that in place, lets get our unit tests going

using System;

using System.Diagnostics;

using BankDAL.Model;

using NUnit.Framework;

using ProfileContract;

namespace Client

    [TestFixture]

    public class Tests

        private void TransferFundsFromSavingsToCheckingAccount(int customerId,

            decimal amount)

            ProxyFacade.CheckingAccountProxy().DepositAmount(customerId, amount);

            ProxyFacade.SavingsAccountProxy().WithdrawAmount(customerId, amount);

        private void TransferFundsFromCheckingToSavingsAccount(int customerId,

            decimal amount)

            ProxyFacade.SavingsAccountProxy().DepositAmount(customerId, amount);

            ProxyFacade.CheckingAccountProxy().WithdrawAmount(customerId,  amount);

        [Test]

        public void CreateAndGetProfileTest()

            IProfile profile = ProxyFacade.ProfileProxy();

            const string customerName = "Tom";

            int customerId = profile.CreateCustomer(customerName, "NJ",

                new DateTime(1982, 1, 1)).Id;

            Customer customer = profile.GetCustomer(customerId);

            Assert.AreEqual(customerName,customer.FullName);

        [Test]

        public void DepositWithDrawAndTransferAmountTest()

            IProfile profile = ProxyFacade.ProfileProxy();

            string customerName = "Smith" + DateTime.Now.ToString("HH:mm:ss");

            var customer  = profile.CreateCustomer(customerName, "NJ",

                new DateTime(1982, 1, 1));

            // Deposit to Savings

            ProxyFacade.SavingsAccountProxy().DepositAmount(customer.Id, 100);

            ProxyFacade.SavingsAccountProxy().DepositAmount(customer.Id, 25);

            Assert.AreEqual(125,

                ProxyFacade.SavingsAccountProxy().GetSavingsAccountBalance(customer.Id));

            // Withdraw

            ProxyFacade.SavingsAccountProxy().WithdrawAmount(customer.Id,  30);

            Assert.AreEqual(95,

                ProxyFacade.SavingsAccountProxy().GetSavingsAccountBalance(customer.Id));

            // Deposit to Checking

            ProxyFacade.CheckingAccountProxy().DepositAmount(customer.Id, 60);

            ProxyFacade.CheckingAccountProxy().DepositAmount(customer.Id, 40);

            Assert.AreEqual(100,

                ProxyFacade.CheckingAccountProxy().GetCheckingAccountBalance(customer.Id));

            // Withdraw

            ProxyFacade.CheckingAccountProxy().WithdrawAmount(customer.Id,  30);

            Assert.AreEqual(70,

                ProxyFacade.CheckingAccountProxy().GetCheckingAccountBalance(customer.Id));

            // Transfer from Savings to Checking

            TransferFundsFromSavingsToCheckingAccount(customer.Id,10);

            Assert.AreEqual(85,

                ProxyFacade.SavingsAccountProxy().GetSavingsAccountBalance(customer.Id));

            Assert.AreEqual(80,

                ProxyFacade.CheckingAccountProxy().GetCheckingAccountBalance(customer.Id));

            // Transfer from Checking to Savings

            TransferFundsFromCheckingToSavingsAccount(customer.Id, 50);

            Assert.AreEqual(135,

                ProxyFacade.SavingsAccountProxy().GetSavingsAccountBalance(customer.Id));

            Assert.AreEqual(30,

                ProxyFacade.CheckingAccountProxy().GetCheckingAccountBalance(customer.Id));

        [Test]

        public void FundTransfersWithOverDraftTest()

            IProfile profile = ProxyFacade.ProfileProxy();

            string customerName = "Angelina" + DateTime.Now.ToString("HH:mm:ss");

            var customerId =

                profile.CreateCustomer(customerName, "NJ", new DateTime(1972, 1, 1)).Id;

            ProxyFacade.SavingsAccountProxy().DepositAmount(customerId, 100);

            TransferFundsFromSavingsToCheckingAccount(customerId,80);

            Assert.AreEqual(20,

                ProxyFacade.SavingsAccountProxy().GetSavingsAccountBalance(customerId));

            Assert.AreEqual(80,

                ProxyFacade.CheckingAccountProxy().GetCheckingAccountBalance(customerId));

try

                TransferFundsFromSavingsToCheckingAccount(customerId,30);

            catch (Exception e)

                Debug.WriteLine(e.Message);

            Assert.AreEqual(110,

                ProxyFacade.CheckingAccountProxy().GetCheckingAccountBalance(customerId));

            Assert.AreEqual(20,

                ProxyFacade.SavingsAccountProxy().GetSavingsAccountBalance(customerId));

We are creating a new instance of the channel for every operation, we will look into instance management and how creating a new instance of channel affects it in subsequent articles.

The first two test cases deals with creation of Customer, deposit and withdraw of month between accounts. The last case, FundTransferWithOverDraftTest() is interesting. Customer starts with depositing $100 in SavingsAccount followed by transfer of $80 in to checking account resulting in $20 in savings account. Customer then initiates $30 transfer from Savings to Checking resulting in overdraft exception on Savings with $30 being deposited to Checking. As we are not running both the requests in transactions the customer ends up with more amount than what he started with $100. In subsequent posts we will look into transactions handling.

Make sure the ServiceHost project is set as start up project and start the solution. Run the test cases either from NUnit client or TestDriven.Net/Resharper which ever is your favorite tool. Make sure you have updated the data base connection string in the ServiceHost config file to point to your local database

Resharper Surround with Templates: ()

skjagini — Wed, 26 Aug 2009 18:37:00 GMT

Resharper comes with live templates (ctrl + j) or surround with templates (ctrl+ alt + j) which helps with few key strokes and can save you considerable time over a period of day.

Of the available surround with templates, my most frequently used one is surrounding with curly braces, { }

If you use linq statements in your code, you will quickly realize how neat it would have been if there were a open and close bracket surround template, ( ).

No worries, it’s easy to create one, lets do it.

From VS.Net, go to Resharper menu and select live templates, switch to the surround templates, as shown in the following pic, notice the predefined templates.

Right click on User Templates, select new template.

Lets give the description and the action to perform and you are all set.

Lets test it. Write your linq query, apply the shortcut ctrl + alt + j and select more options.

Select the open and close bracket from User Templates and mark the Add to quick list option and you will get your linq query surrounded with ( ) brackets.

Next time when you select surround with, you will get your shortcut,

Write your linq, select the statement using ctrl + w (Resharper) and surround with brackets and continue the operation.

 (from accountDetailEntity in accountDetailEntities

     group accountDetailEntity by accountDetailEntity.AccountBalance

          into grouping

               select grouping). <--

Nice,  these simple shortcuts saves a good amount of time . Thanks Resharper :)

Timeout exceptions

skjagini — Mon, 24 Aug 2009 15:48:00 GMT

1. WCF

In a typical WCF client-service application, the client initiates the requests and waits for the response from service. If the service doesn’t respond in the preconfigured intervals the client will error out with an exception similar to the following exception:

System.TimeoutException: The request channel timed out while waiting for a reply after 00:00:00.1718750. Increase the timeout value passed to the call to Request or increase the SendTimeout value on the Binding. The time allotted to this operation may have been a portion of a longer timeout. ---> System.TimeoutException: The HTTP request to 'http://localhost:8888/SaveProducts' has exceeded the allotted timeout of 00:00:00.7810000. The time allotted to this operation may have been a portion of a longer timeout. ---> System.Net.WebException: The operation has timed out
   at System.Net.HttpWebRequest.GetResponse()
   at System.ServiceModel.Channels.HttpChannelFactory.HttpRequestChannel.HttpChannelRequest.WaitForReply(TimeSpan timeout)
   --- End of inner exception stack trace ---

There are four parameters that you can configure to avoid timeout: open timeout, close timeout, send timeout, receive timeout.

The parameters open timeout and close timeout are same in both the client and service configurations.

Open timeout: Time required to open the channel

Close timeout: Time required to close the channel

Case: Client sends a requests and waits for the service to respond

On the client side

Send timeout: Time required to send the message to the service and receive the response
Receive timeout: Not applicable on client side

On the service side

Send timeout: Not applicable
Receive timeout: Not applicable on

We can overwrite the time intervals either through web.config or programmatically in the code

Find the client’s web.config as an example

  <system.serviceModel>

    <bindings>

      <wsHttpBinding>

        <binding name="AdventureworksWsHttpBinding"

                 maxReceivedMessageSize="100000000" sendTimeout="00:10:00"

                 transactionFlow="true"

          <reliableSession enabled="false" />

          <security mode="None"  />

        </binding>

      </wsHttpBinding>

    </bindings>

    <client>

      <endpoint address="http://localhost:8888/SaveProducts"

            binding="wsHttpBinding" bindingConfiguration="AdventureworksWsHttpBinding"

            contract="Adventureworks.Service.ISaveProducts"

            name="Adventureworks" />

    </client>

  </system.serviceModel>

The following snippet shows how to overwrite using the code

ChannelFactory<ISaveProducts> channelFactory = new ChannelFactory<ISaveProducts>("Adventureworks");

channelFactory.Endpoint.Binding.SendTimeout = new TimeSpan(0,0,10,0);

service = channelFactory.CreateChannel();

Similarly increase the open timeout and closetime out on the service config file

2. IIS

If you have deployed your services on IIS don’t forget increase execution time from the default 1 min 50 seconds

  <system.web>

    <httpRuntime executionTimeout="600"/>

  </system.web>

3. Database (SQL Server specific)

On the database front, the requests can timeout either for failure to open the connection or do the operation.

Connection timeout: The time taken to open the connection to the database

You can overwrite the default connection timeout (15 seconds) using ‘Connect Timeout = 30’ as part of the connecting string parameters.

Or can overwrite programmatically, SqlConnection.ConnectionTimeout

Command timeout: The time taken to execute the command on the database

SqlCommand.CommandTimeout can be used to overwrite the command timeout.

Starting with LLBLGenPro in your Project

skjagini — Wed, 22 Jul 2009 01:15:00 GMT

LLBLGenPro is an object relational mapper which generates code for the data access layer from the database, in the coming releases it’s been planned to engineer from LLBL Project to create database. I am using v2.6 in my current project and happy with it so far. One of the strong points of v2.6 is it has good Linq support.

You can also look into other ORMs with Linq support including Entity framework (Microsoft), Linq to SQL (Microsoft) and Subsonic. Entity framework is going through a major overhaul in version 4.0 and can also expect some improvements in Linq to SQL. Subsonic is an open source project maintained by Rob Connery, the MVC-Storefront dude.

And keep in mind that the following article uses LLBLGenPro Professional edition, and checkout their website for more on licensing, etc.

I have arranged the article into the following sections

Project types: SelfServicing or Adapter paradigm
Configure the Project using LLBLGenPro Editor
Generate the Code using Adapter paradigm
Your VS.Net Solution
Writing your first test
Debugging and catalog name overwrites
Conclusion

1. Project types: SelfServicing or Adapter paradigm

You can create a SelfServicing or Adapter paradigm. In SelfServicing objects are lazy loaded from the database, and once loaded they don’t load again. Adapter pattern doesn’t support lazy loading, and you need to fetch all your objects and save them by yourself. Adapter is best suited if you are providing a service and you don’t expect your client to load them. We will generate project with Adapter paradigm in this write up.

2. Configure the Project using LLBLGenPro Editor

LLBLGenPro comes with an easy to use editor to generate the project from database. Open the LLBLGenPro editor from Programs and create a new project. Provide your project information, choose the appropriate driver and select the catalog to work with.

Once you create the project, you will notice your project explorer being updated with the Catalog, gives a skeleton for your entities, views and stored procedures.

You can add entities by choosing ‘Add new entities mapped on tables from Catalog’ on the context menu when you right click on Entities which pops a modal box with the available tables to choose from.

I am interested in Product and it’s related tables, lets add them to the Project. Once you add to the project you can notice your Entities in Project Explorer being updated. And you can also change the Field Names to more meaningful.

On the bottom if you notice the ‘Fields on relations’ tab, the editor has generated the table relations for you by looking at your database Primary/Foreign Key relationships.

The editor is not clever enough to pluralize the relationships, so change them by editing the Field Name.

If you feel you need relations that are not provided in the database, you can create them easily using ‘Add new custom 1:1//1:n/m:1 relation’ on the ‘Relations’ tab

Select the tables and fields on which you want to create the relations and you are good to go.

From the Project menu select the Properties and customize the generated code.

I usually set the following properties to my needs:

CatalogRefresher:-
Add NewElementsAfterRefresh: False (Don’t want to get new tables added automatically to my project)
Name construction:-
EnforcePascalCasingAlways: False
MakeElementNamePascalCasing: False
Output settings:-
RootNamespace: AdventureWorks
Task performers:-
FailCodeGenerationOnWriteError: True (If you use TFS, and the projects are not checked out, you need to enable this option)
CleanUpVsNetProjects: False

Have also changed the Project file suffix names to more meaningful as you can see under ‘Task performers’ in the above image.

3. Generate the Code using Adapter paradigm

Lets jump on and generate the code using Generate on the Project menu.

Make sure select the correct template group, your target platform, language, and location.

4. Your VS.Net Solution

I have Adventureworks solution with 3 projects and lgp.

Generated projects
- Adventureworks.DAL.Adapter
- Adventureworks.DAL.Domain
Adventureworks.Tests: Add the project reference to the above projects

For each of the Entities selected through the editor, a separate entity class is generated. Since these classes are generated you don’t want to manually edit them, the editor has template support to customize the code generation, and you can also partial classes to add additional behavior.

5. Writing your first test

With the solution in place, we can write some test cases, finally :)

using System.Linq;

using AdventureWorks.DAL.Adapter;

using AdventureWorks.DAL.Linq;

using NUnit.Framework;

namespace Adventureworks.Tests

    [TestFixture]

    public class GetProductsTestFixture

        [Test]

        public void GetAllProductsTest()

            DataAccessAdapter adapter = new DataAccessAdapter();

            var linq = new LinqMetaData(adapter);

            var productQeury = (from p in linq.Product

                                select p);

            var product = productQeury.FirstOrDefault();

            Assert.AreNotEqual(product, null);

            Assert.AreNotEqual(product.ProductName,null);

And you can successfully run the test case. My next question is how do I check the SQL generated?

6. Debugging and catalog name overwrites

Debugging:

It is a good practice to look at the SQL query generated to make sure you are getting your Linq statement correctly until you gain handle over it. Even though Linq is part of the language, universal across objects, xml and database entities it doesn’t mean that the constructs supported in Linq to objects are supported in Linq to database. And after all each 3rd party linq provider has their own SQL query generation engine.

LLBLGenPro has support for various databases. For SQL Server and Oracle, you can check the SQL generated by adding the following diagnostics under system.diagnostics tab in your App.Config of the test project. Make sure you rebuild the projects for the changes to be copied to the output directory.

<?xml version="1.0"?>

<configuration>

    <system.diagnostics>

      <switches>

        <add name="SqlServerDQE" value="4" />

      </switches>

      <!--<switches>

        <add name="OracleDQE" value="4"/>

      </switches>-->

    </system.diagnostics>

</configuration>

I am using Resharper plug-in for Visual Studio to run my rest cases, and you can see the query being generated. Nice :)

Catalog name overwrites:

Before delving into catalog name overwrites, lets me show you how to read the connection string for Adventureworks database using the App.config file

Step 1: Create a custom Adapter which reads the connection string from Configuration file.

Step 2: Add AdventureWorksAdapter.cs to the AdventureWorks.DAL.Adapter.

Step 3: Fill the AdventureWorksAdapter.cs

using System.Configuration;

namespace AdventureWorks.DAL.Adapter

    public class AdventureWorksAdapter : DataAccessAdapter

        public AdventureWorksAdapter(string connectionString)

            : base(connectionString)

        public static AdventureWorksAdapter GetAdapter()

            ConnectionStringSettings connection =

                new ConnectionStringSettings("Adventureworks",

                    ConfigurationManager.AppSettings["Adventureworks.ConnectionString"]);

            return new AdventureWorksAdapter(connection.ConnectionString);

Step 4: Update the App.Config file

<?xml version="1.0"?>

<configuration>

    <appSettings>

        <add key="Adventureworks.ConnectionString" value="data source=.;initial catalog=AdventureWorks;integrated security=SSPI;persist security info=False;packet size=4096"/>

    </appSettings>

Step 5: Update the test method to use the AdventureWorksAdapter.cs

        [Test]

        public void Get_First_Product_Test()

            //DataAccessAdapter adapter = new DataAccessAdapter();

            AdventureWorksAdapter adapter =AdventureWorksAdapter.GetAdapter();

            var linq = new LinqMetaData(adapter);

            var productQeury = (from p in linq.Product

                                select p);

            var product = productQeury.FirstOrDefault();

            Assert.AreNotEqual(product, null);

            Assert.AreNotEqual(product.ProductName,null);

Now, lets run the test method, it successfully completes. Lets not jump, we have a gotcha here.

If you change your connection string in the App.Config to reference another instance of Adventureworks database, lets call it Test Server, and run the test case. Open the SQL Server Profiler on your Test database, you will not notice any activity from your client.

LLBLGenPro caches the Connection string used to generate the project file, even though your App.Config is pointing to your Test Server.

To suppress the cached connection string you need to overwrite the catalog names.

Catalog Name Overwrites:

Step 6: Update your App.Config with catalog overwrites.

Open your App.Config in AdventureWorks.DAL.Adapter and check the name of your initial catalog

Step 7: Overwrite the initial catalog.

Add config sections for sqlServerCatalogNameOverwrites and it’s values. I am also including commented Oracle catalog name overwrites

Find the complete App.Config below.

<?xml version="1.0"?>

<configuration>

  <configSections>

    <section name="sqlServerCatalogNameOverwrites" type="System.Configuration.NameValueSectionHandler" />

    <!--<section name="oracleSchemaNameOverwrites" type="System.Configuration.NameValueSectionHandler" />-->

  </configSections>

  <appSettings>

        <add key="Adventureworks.ConnectionString" value="data source=.;initial catalog=AdventureWorks;integrated security=SSPI;persist security info=False;packet size=4096"/>

    </appSettings>

    <system.diagnostics>

      <switches>

        <add name="SqlServerDQE" value="4" />

      </switches>

      <!--<switches>

        <add name="OracleDQE" value="4"/>

      </switches>-->

    </system.diagnostics>

  <sqlServerCatalogNameOverwrites>

    <add key="AdventureWorks" value="" />

  </sqlServerCatalogNameOverwrites>

  <!--<oracleSchemaNameOverwrites>

    <add key="MySchema" value ="" />

  </oracleSchemaNameOverwrites>-->

</configuration>

Step 8:

Run the test case again and check the profiler on your Test database, and you will see the query.

7. Conclusion

This shall help you in getting started, starting from using the editor to generate the code –> writing your first test case. In my next post I will cover how to write some complex Linq queries, prefetch data and using stored procedures.

Happy programming.

My most frequently used Resharper and VS.Net Shortcuts

skjagini — Mon, 20 Jul 2009 04:34:00 GMT

1. Resharper

ReSharper is a VS.Net Plug-in that gives you solution wide error analysis with lots of refactoring features.

I can say with confidence that my productivity has gone up after I started using this tool and completely addicted to it.

These are some of the shortcuts I regularly use. In version 4.5 some of these tasks have been given new shortcuts but the old one still works.

(2.5): Shortcuts from Version 2.5

(4.5): Shortcuts from Version 4.5

Go To

Go to Type: Ctrl + N (2.5) (or) Ctrl + T (4.5)

Go to File: Ctrl + Shift + N (2.5) (or) Ctrl + Shift + T (4.5)

Go to Type declaration: Ctrl + Shift + T (2.5) (or) Ctrl + Shift + F11

Go to File Member: Ctrl + F12

Go to next Error: F12 (2.5) (or) Shift + Alt + Page Down (4.5)

Go to Declaration: Ctrl + B (2.5) (or) F12 (4.5)

Go to Implementation (or Inheritor): Ctrl + Alt + B

Go to previous Error: Shift + F12 (2.5) (or) Shift + Alt + Page Up (4.5)

Recent Files: Ctrl + E (2.5) (or) Ctrl +, (4.5)

Locate in Solution Explorer: Shift + Alt + L

Go to Usages: Ctrl + Alt + F7

Find Usages (Window): Alt + F7

Coding Analysis

Alt + Enter: For Quick fixes and context actions

Symbol Code Completion: Ctrl + Space

Move Code Up: Ctrl+Shift+Alt+Up Arrow

Move Code Down: Ctrl+Shift+Alt+Down Arrow

Extend Selection: Ctrl + w (2.5) (or) Ctrl+ Alt + Right Arrow (4.5)

Shirt Selection: Ctrl+ Shift+ w(2.5) (or) Ctrl + Alt+ Left Arrow (4.5)

Enable/Disable Code analysis in the current file: Ctrl + 8

Method information: Ctrl + Q

Refactoring

Refactor this: Ctrl + Shift + R

Rename: F2 (2.5) (or) Ctrl + R, R (4.5)

Move Type or Member: F6 (2.5) (or) Ctrl + R, O

Change signature: Ctrl + F6 (2.5) (or) Ctrl + R, S

Code Generation

Generate Code (Constructors, properties etc in class file): Alt + Ins

Create file from Template (Classes, Interfaces, folder in Solution Explorer): Alt + Ins

Insert Live Templates: Ctrl + J (2.5) (or) Ctrl+E, L (4.5)

Surround with Live Templates: Ctrl + Alt + J (2.5) (or) Ctrl+E, U (4.5)

2. My favorite VS.Net Shortcuts

Navigation

Go to last line of Location: Ctrl + minus

Go to next line of Location: Ctrl + Shift + minus

Code View: F7

Designer View: Shift + F7

Close the File: Ctrl + F4

Switch between Tabs: Ctrl + Tab

Code Formatting

Reformat the Code: Ctrl + K Ctrl + F

Comment the Code: Ctrl + K Ctrl + C

Uncomment the Code: Ctrl + K Ctrl + U

Wrap the Code: Ctrl + R Ctrl + R (VS 2003) (or) Ctrl + E Ctrl + E Ctrl + W (later)

Since Ctrl + E is recent files in Resharper, I have set it to Ctrl + R Ctrl + W. Works in output window also

Select Text Vertically: Alt + Drag cursor

Debugging

Breakpoint toggle: F9

Build: Ctrl + B

Run: F5

Step Over: F10

Step Into: F11

Step Out: Shift + F11

Run to Cursor: Ctrl + F10

Extension methods – ForEach statement

skjagini — Sun, 19 Jul 2009 17:41:00 GMT

One of the features introduced along with .Net framework 3.5 is Extension methods which allows to extend a class by adding new methods without actually deriving from the class or changing the source code. They are extremely handy to extend multiple classes by extending the common interface, .. ok lets take them one at a time.

I will show by example in the following order

1. To extend a class

2. To extend an Interface

1. Extend a Class

Step 1:

Consider a User class with two properties, FirstName and LastName and a method for getting the full name, FullName

namespace ExtensionMethods

    public class User

        public string FirstName { get; set; }

        public string LastName { get; set; }

        public string FullName()

            return FirstName + " " + LastName;

Given the above class, we can write a test method to verify the full name,

        [Test]

        public void Given_FirstName_And_LastName_Verifies_The_Full_Name()

            User user = new User()

                                   FirstName = "Sujith",

                                   LastName = "Jagini"

};

            Assert.AreEqual("Sujith Jagini", user.FullName());

All is well, the test completes successfully.

Step 2:

Let’s say the User class is being provided without method, FullName and we don't have access to the source to include or request for.

    public class User

        public string FirstName { get; set; }

        public string LastName { get; set; }

        //public string FullName()

//{

        //    return FirstName + " " + LastName;

//}

No worries, we can calculate the full name

        [Test]

        public void Given_FirstName_And_LastName_Calculates_The_Full_Name()

            User user = new User

                                   FirstName = "Arnold",

                                   LastName = "Schwarzenegger"

};

            Assert.AreEqual("Arnold Schwarzenegger", user.FirstName + " " + user.LastName);

As you can see from the above test method, it is ugly that when ever we need full name we need to calculate it from first and last name and to remember the number of spaces between first and last name.

Step 3:

To avoid repetition of code, we can introduce a UserHelper class which holds all the helper methods for the User class.

namespace ExtensionMethods

    public class UserHelper

        public static string GetFullName(User user)

            return user.FirstName + " " + user.LastName;

And our test case shall utilize this new Helper class,

        [Test]

        public void Given_UserInstance_Gets_The_FullName_Using_UserHelper()

            User user = new User

                FirstName = "Tom",

                LastName = "Cruise"

};

            Assert.AreEqual("Tom Cruise", UserHelper.GetFullName(user));

Even though this works the functionality defined in separate classes, User and UserHelper which are not very close to each other.

Step 4:

Welcome to Extension methods. With the help of Extension methods we can extend the class without actually touching it.

namespace ExtensionMethods

    public static class UserExtension

        public static string FullName(this User user)

            return user.FirstName + " " + user.LastName;

Extension methods have to be defined in static class with a static method. The first parameter of the method with the this User tells the compiler that we are extending the User class with FullName.

We can have a test method that can use the FullName Extension method.

        [Test]

        public void Given_UserInstance_Gets_The_FullName_Using_UserExtension()

            User user = new User

                FirstName = "George",

                LastName = "Clooney"

};

            Assert.AreEqual("George Clooney", user.FullName());

2. Extend an Interface

The beauty of extensions methods not lies in extending classes, it's the interfaces which can be extended gives the real kicker.

Let’s say we have an array of Users and like to get their Full Name in upper case letter. We can use the foreach loop.

        [Test]

        public void Iterate_Over_Array_Of_Users_Using_foreach_Loop()

            User[] users = new User[]

                                   new User(){FirstName ="Angelina",LastName = "Jolie"},

                                   new User(){FirstName ="Jennifer",LastName = "Jolie"},

                                   new User(){FirstName ="Halle",LastName = "Berry"},

};

            foreach (User user in users)

                Debug.WriteLine(user.FullName().ToUpper());

We can rewrite the above foreach loop for code readability and Linq chaining. For this we need to convert Array to List to make use of the ForEach method which takes Action as delegate

        [Test]

        public void Iterate_Over_Array_Of_Users_Using_ForEach_Method_On_List()

            User[] users = new User[]

                                   new User(){FirstName ="Angelina",LastName = "Jolie"},

                                   new User(){FirstName ="Jennifer",LastName = "Jolie"},

                                   new User(){FirstName ="Halle",LastName = "Berry"},

};

            users.ToList().ForEach(u => Debug.WriteLine(u.FullName().ToUpper()));

Converting Array to List is costly, to overcome this we can extend the built in IEnumerable interface to introduce a new ForEach method.

using System;

using System.Collections.Generic;

namespace ExtensionMethods

    public static class IEnumerableExtension

        public static void ForEach<T>(this IEnumerable<T> list, Action<T> action )

            if (action == null)

                throw new ArgumentNullException("action");

            foreach (T item in list)

                action(item);

And we can rewrite the test method using the ForEach Extension, notice we are not converting array to list.

        [Test]

        public void Iterate_Over_Array_Of_Users_Using_ForEach_Extension()

            User[] users = new User[]

                                   new User(){FirstName ="Angelina",LastName = "Jolie"},

                                   new User(){FirstName ="Jennifer",LastName = "Jolie"},

                                   new User(){FirstName ="Halle",LastName = "Berry"},

};

            users.ForEach(u => Debug.WriteLine(u.FullName().ToUpper()));

There you go, you have extended the IEnumerable Interface without changing it’s structure.

By extending an interface we are able to extend all the classes that implement the interface like Collections, Dictionaries etc. Linq2Objects is actually implemented through extension methods in Enumerable class extending IEnumerable interface with lots of query operators including Sum, Where, Order By etc.

Windows Live Writer + Code Snippet Plug-in = Happy blogging

skjagini — Thu, 16 Jul 2009 16:42:00 GMT

If you are a avid blogger, and haven’t heard of Windows Live Writer (WLW) then you are living in a cave, can you think of any of those Geico ads :)

For example think of an email editor, where you longer need to connect to email provider site, depend on internet connectivity to write email (offline support) and work with the WYISIWYG editors.

WLW allows you to write blog posts which can be seamlessly published, updated and deleted from the blog and has lots of options for formatting

The true power of the WLW comes from the support for Plug-ins and I totally love this code snippet downloadable from CodePlex.

Code sample (c#)

public static void ValidateLoss(LossEntity loss, Result result)

    if(!HasChildCollections(loss,result))

        return;

    CheckHeader(loss, result);

Nice isn’t it !!

Disposing the resources when process exits

skjagini — Wed, 28 Nov 2007 22:10:00 GMT

while browsing the System.AppDomain in reflector found this gem that can be very useful to cleanup the resources when the application exits.

The event, System.AppDomain.CurrentDomain.ProcessExit takes delegate which invokes the method to dispose the resources. When used along with anonymous delegates the syntax looks even pretty

private Resource1 MyResource;

// Constructor
public MyExternalResources() {

    // Assign the value for objResource
    MyResource = HelperClass.GetResource(..);

     // Clean up the resources when the Current Application Domain exits
    System.AppDomain.CurrentDomain.ProcessExit += delegate
                                                  { 
                                                      // Close the resources
                                                      MyResource.Close(); 
                                                  }            
 }

Orchestrations that use Singleton classes with Dispose pattern

skjagini — Wed, 25 Oct 2006 20:58:00 GMT

Recently I had to convert an orchestration from singleton to non singleton. Orchestration was implemented as singleton as it had to process the incoming requests in sequential order. As sequential processing was no longer a requirement, I was being assigned to convert it to non singleton.

It was a cake walk all through except for reading the values from registry. In singleton orchestration, it can read and store values from registry (ok, there are still some organizations that depend on registry for lot of configuration, .. legacy) before the start of loop and was fine. When converted to non singleton, I no longer have the freedom to go registry for every orchestration instance.

Approach 1 (not recommended):

Started with a singleton .Net class which caches the registry values and uses PInvoke to monitor the registry values. Since it uses PInvoke, the class needs to implement Dispose pattern. As the class is used by the orchestration instances, it is not possible to call Dispose() method from an orchestration as it is being used by other. And Finalization is the only way for the class to get Garbage Collected; Finalization is not only costly but also there is no order in which Finalize() gets executed. And not a recommended solution.

Approach 2:

Instead of using PInvoke to monitor the registry to avoid invoking the Dispose, we can use polling to update local cache for every 5 minutes (configurable) with the help of System.Threading.Timer along with System.Threading.ReadWriteLock to control the access to the shared variables. For implementation details look into BizTalk 2006/sdk/scenarios.

The conclusion, singleton .Net Classes which implement Dispose pattern is not a good fit with non singleton Orchestrations.

Google Reader

skjagini — Wed, 25 Oct 2006 20:34:00 GMT

I see some light here.

I have switched my RSS reader from Sharp Reader to Google’s Reader. It has a nice interface, best of all I can access my feeds from any computer, no need to sync from my work to home pc, hurray:)

Adding the following features can make it much better experience.

1. Able to see starred(*) items of a particular feed and filtering on tags for a particular feed.

2. Able to select multiple items at one time using something like a check box and applying tags, stars etc to all of them in a single click

3. How about what they are good at, searching the feeds

Noise about RETE and BizTalk

skjagini — Sun, 28 Aug 2005 20:29:00 GMT

If you like to know about the BizTalk Rules Engine inner workings, look into the Charles Young comments on Serverside.net about BizTalk Server and its RETE implementation (Rules Engine).

Hello World

skjagini — Wed, 24 Aug 2005 20:18:00 GMT

This is my first post, I will do my best to write as many good posts as I can. I am a .NET developer at heart, work with BizTalk Server and other typical Microsoft stack. These days I am into Agile and TDD.

Have had my blog with GeeksWithBlogs, but I am making my switch to Weblogs on Asp.Net.

I seriously feel like I need to be more active blogger and do it periodically