Jon Lanceley's .Net Blog

Setting up an Azure DevOps Post Deployment Gate that checks Application Insights for any Server Exceptions in the last 10 minutes.

2018-12-22T06:55:00.001+00:00

We have a release pipleline which deploys a web site to an Azure App Service and then runs a bunch of Selenium tests against the website.

However that does not test the Azure Function we also deploy. Nor does it check for any errors being reported by the server.

What we will do is make use of a Post Deployment Gate, which will go and look inside Application Insights and check if any Server Exceptions were logged in the time since the web site was released.

If any server exceptions are found then the release will not progress to the next environment.

1. Enable API Access in Application Insights

Create an API Key if you do not already have one e.g.

2. Add a ‘Post Deployment’ gate

In the release definition click ‘Post-deployment conditions’ then enable ‘Gates’.

Set the delay before evaluation = 2 minutes (this allows extra time for the application insights data to come in before the gates are evaluated, although data should be there because Selenium tests will be running before this step)

Add an Invoke REST API task

Connection type: Generic

Generic service connection: Choose the one for the application insights account or Click ‘Manage’ and add this:

New Service Connection -> Generic

Connection name: give it a name e.g. Application Insights Connection

Server URL: https://api.applicationinsights.io/v1/apps/

Username & password can remain empty

e.g.

Method: Post

Headers (replace with this):

{

     "Content-Type":"application/json",

     "x-api-key": "$(ApplicationInsightsAPIKey)"

}

Body:

For all server exceptions use:

{

    "query": "exceptions | where client_Type != 'Browser' | where timestamp > ago(10m) | count"

}

To filter exceptions to within an assembly you can use (e.g. for all Unity server exceptions):

{

    "query": "exceptions | where client_Type != 'Browser' | where assembly contains 'Unity' | where timestamp > ago(10m) | count"

}

Or to filter on trace messages

e.g. If you have an Azure Function that sends emails and writes a trace message when it’s running you can ensure emails are not failing by checking the trace messages.

{

    "query": "traces | where operation_Name == 'SendEmailFunction' | where message contains 'Success' | where client_Type != 'Browser'| where timestamp > ago(10m)| count"

}

Note: The timestamp is something to play around with, it basically needs to cover:

The time the automated Selenium tests take to run (start to finish) - for us approx. 2 minutes

+ ‘the delay before evaluation’ (2 minutes we set above)

+ If the Gates fail they re-evaluate until the 6 minute timeout so we need to ensure the time range allows for this too.

The reason for this is once the Selenium tests stop they will not generate application insights data so by the time it re-evaluates the gate again there may be no data in app insights and the gate would incorrectly pass.

Therefore we need to be checking around the last 10 minutes worth of Application Insights data

Url suffix and parameters:

$(ApplicationInsightsApplicationID)/query

Advanced

Completion event:

ApiResponse

Success criteria (The below checks for a count of 0 records to be returned):

    eq(jsonpath('$.tables[0].rows[0]')[0][0],0)

Or this makes sure there are records being returned (e.g. > 0)

    ne(jsonpath('$.tables[0].rows[0]')[0][0],0)

Evaluation options

Time between re-evaluation of gates: 5 minutes

Minimum duration for steady results after a successful gate evaluation: 0 minutes

The timeout after which all gates fail: 6 minutes

Gates and approvals: On successful gates, ask for approvals

Example:

3. Set Release variables

Add these keys with a scope to the Environment you are releasing:

ApplicationInsightsAPIKey - This one should be a secret so hide the value

ApplicationInsightsApplicationID

4. Save and test it by creating a release

Useful Websites

The API Explorer web site was very useful in constructing the correct message

https://dev.applicationinsights.io/apiexplorer/postQuery

Application Insights ‘Analytics’ was useful in constructing the query

Zero downtime Azure App Service deployments with EF6 Code First Migrations and MVC5

2018-02-17T06:54:00.001+00:00

This post is about how we deploy our production web sites to an Azure Web App Service and execute Entity Framework 6 code first migrations as part of a VSTS Release process.

A little bit of history:

What we were doing was running dbMigrator.Update() on the start of the website.

So in Startup.cs we had this:

var efConfiguration = new Configuration();

var dbMigrator = new System.Data.Entity.Migrations.DbMigrator(efConfiguration);

dbMigrator.Update();

This worked well, it upgraded the database, and applied any seed data. The downside was the site became unusable until all this had finished which for us was about 1 minute.

This also had a major downside when we turned on Azure auto scaling on the App Plan, when it scaled to more than 1 instance, all instances started up, and all of them called dbMigrator.Update(). Resulting in a fair number of exceptions and the site failing to start.

What we now do:

We needed to remove the database logic from Startup.cs and do it as part of the VSTS Release process instead. So we deploy the site to a staging slot, execute database migrations via Migrate.exe into the production database (on the build server), and then swap the staging slot to production.

This does mean the production web site code is running against a newer database schema until the site swaps over, but this is fine as long as the developers code to handle current and current-1 database versions. This is how production now looks, sharing the same database.

How to implement this:

1. The build Process

As well as packaging up the website into its own Artifact we now package up as another Artifact all the files we need in order to run migrate.exe, so we have 2 extra build tasks as part of our Main branch build:

In the contents section:

line 1 : Copies our dll’s containing our entity framework migrations

line 2: Copies the DeployDatabase.ps1 PowerShell script below

line 3: Copies the migrate.exe provided by Entity Framework in the packages folder.

The DeployDatabase.ps1 PowerShell file contains:

# DeployDatabase.ps1

[CmdletBinding()]

Param(

[Parameter(Mandatory=$True,Position=1)]

[string]$webAppName,

[Parameter(Mandatory=$False,Position=2)]

[string]$slotName,

[Parameter(Mandatory=$False,Position=3)]

[string]$slotResourceGroup

)

cls

$ErrorActionPreference = "Stop" # Stop as soon as an error occurs

if($slotName -ne $null -and $slotName -ne '') {

$isSlot = $True

}

else {

$isSlot = $False

}

Write-Host "PSScriptRoot : " $PSScriptRoot

Write-host "Web app: " $webAppName

Write-Host "Using slot: " $isSlot " " $slotName

Write-Host "SlotResourceGroup: " $slotResourceGroup

$dll = "SiteDataAccess.Extended.Customer.dll"

Write-Host "Using dll: " $dll

if($isSlot) {

$GetWebSite = Get-AzureRmWebAppSlot -Name $webAppName -Slot $slotName -ResourceGroupName $slotResourceGroup

}

else {

$GetWebSite = Get-AzureRmWebApp -Name $webAppName

}

$Connection = $GetWebSite.SiteConfig.ConnectionStrings | Where {$_.name -eq "ExtendedSiteDBContext"}

$ConnectionString = $Connection.ConnectionString

Write-host "Executing Database migrations and seeding with Migrate.exe"

& "$PSScriptRoot\migrate.exe" $dll /connectionString=$ConnectionString /connectionProviderName="System.Data.SqlClient" /verbose

if ($LastExitCode -ne 0) {

throw 'migrate.exe returned a non-zero exit code...'

}

Write-host "Finished executing Database migrations and seeding with Migrate.exe"

Write-host "Finished"

What that script does when called from an Azure Powershell task in a Release definition is lookup the connectionString from the web app service in Azure and then uses that to call migrate.exe. We did this so we did not have to store any connectionStrings in VSTS. If the sql user in the connectionString used when executing migrate.exe needs different permissions to that of the website you could change this to use VSTS release variables instead.

2. The Release definition

When we release a site our process is:

· Stop the deployment slot ‘stage’

· Deploy the website zip to slot ‘stage’

· Update the database using the PowerShell script

· Start the Stage site

· Swap Stage with production

· Ping production site

· Stop the stage site (to save resources)

Our release definition looks like this:

Release definition

Task Groups

The Update Database task is just an Azure PowerShell task containing:

In Azure the App Service Plan is configured so that the production site and the stage slot are almost identical (baring a few appSetting values). They share the same connectionString and every appSetting and ConnectionString value has the ‘Slot Setting’ checkbox ticked.

Our big gotcha

Was during the swap slots task the website will be warm started automatically by that process hitting localhost under http, or it will try the domain name of the site but again under http. We had this in our filter.config

// Ensure all http connections are redirected to https

filters.Add(new RequireHttpsAttribute());

Which meant the warm start process instantly failed to start the site, the swap process continued and the site then started up from cold in production. We could see that because our ping task that pinged the production site, was taking a minute to respond.

What we had to do was create a custom version of the RequireHttpsattribute, once we did this our ping task responds in 1-3 seconds:

// Ensure all http connections are redirected to https

filters.Add(new CustomRequireHttpsAttribute());

And the code for the attribute is:

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]

public class CustomRequireHttpsAttribute : RequireHttpsAttribute

{

protected override void HandleNonHttpsRequest(AuthorizationContext filterContext)

{

string ipAddress = filterContext.RequestContext.HttpContext.Request.UserHostAddress;

var userAgent = filterContext.RequestContext.HttpContext.Request.UserAgent.ToLower();

// 0.0.0.0 and 127.0.0.1 and ::1 are used by the Azure App Service Swap Slot process to Warm up the site before swapping the slot to production

if(ipAddress == "0.0.0.0" || ipAddress == "::1" || ipAddress == "127.0.0.1")

//if(userAgent.Contains("sitewarmup")) // doesnt work

{

return;

}

base.HandleNonHttpsRequest(filterContext);

}

Setup Application Gateway & the Internal Front-End Load Balancer for an application

2017-04-23T11:50:00.001+00:00

Setup Application Gateway & the Internal Front-End Load Balancer for an application

This post follows on from the one on creating a service fabric environment in Azure http://jonlanceley.blogspot.co.uk/2017/04/3-node-service-fabric-environment-with.html

After you have deployed an application to service fabric you need to add the port for it to the service fabric cluster Front End load balancer and then to the Application Gateway.

1. Front End load balancer

The port is the one you have defined in your serviceManifest.xml e.g.

</Endpoints>

</Resources>

</ServiceManifest>

Create a new Health Probe

e.g. 8702Probe

Create a new Load balancing rule

e.g. 8702Rule, make sure you set the highlighted items correctly.

2. Application Gateway

Add a new Health Probe

The path just needs to be an endpoint which can return a response so the health probe knows if the application is alive.

Add a new Http Setting

Add a new Mult-Site Listener

Add a new Basic rule

Make sure you choose the httpSetting you created earlier

Remove rule1 for the appGatewayHttpListener

Check the backend health

Before connecting via a browser it’s worth checking that the Backend health report is Healthy otherwise you have missed something.

If it’s healthy, try opening your application in a browser e.g.

http://sfapptest.com/api/values/get

3 Node Service Fabric Environment with an Azure Application Gateway

2017-04-19T19:36:00.001+00:00

This is an article I put together as I was experimenting with Service Fabric for a real world solution to a problem we had.

In it we will create a service fabric environment in Azure which contains 3 node types, FrontEnd, BackEnd, and Management, plus an Application Gateway in front which all internet traffic can be routed through to the FrontEnd node. We will also be using an existing Virtual Network and Subnets that we will put the service fabric cluster into.

This post helped me a lot with producing this solution:

https://brentdacodemonkey.wordpress.com/2016/08/01/network-isolationsecurity-with-azure-service-fabric/

My template originally came from the Azure Portal when creating a new service fabric cluster there is the option of saving it as a template. It was then customised as the portal wizard does not let you do certain things. Most of the customisations came from this site:

https://docs.microsoft.com/en-us/azure/service-fabric/service-fabric-patterns-networking

This is what we will build:

The FrontEnd node type is where we put any stateless services.

The BackEnd node type is where we would put any stateful services.

The Azure service fabric services will run on the Management / Primary node type.

· This has a public static outbound IP number, so we can connect to view the status of the cluster.

· It can also host services which need to connect out to a third party which have IP security on their firewall. The third party then only needs to add this IP number to their firewall.

· We can also use this to securely access an Azure SQL database that has IP restricted access.

The steps below are my notes for creating the service fabric environment. All the scripts and ARM template are available on Github:

https://github.com/jonlanceley/jonlanceley/tree/master/CreateServiceFabricEnvironment

1. Create Service Fabric dependencies.

· Public Static IP (for Management nodeType)

· Key Vault (for service fabric certificates)

· Active Directory Application (for authentication)

· Resource Group to put service fabric cluster in

· Existing Virtual Network with 4 subnets for:

o FrontEnd

o BackEnd

o Management

o WAF / Application Gateway

Edit & change the parameters as required in this script:

Azure-CreateDependanciesForServiceFabricPlatform.ps1

Execute the script

Note: this script will prompt you yes/no to create each of the above items.

If you’re creating a non-development version we do not want to use a self-signed certificate so say ‘no’ when prompted. After the script has run you then need to manually add certificates into the key vault. Details here:

https://docs.microsoft.com/en-us/azure/service-fabric/service-fabric-cluster-creation-via-portal#add-certificates-to-key-vault

https://blogs.technet.microsoft.com/kv/2016/09/26/get-started-with-azure-key-vault-certificates/

2. Create the Service Fabric Environment

This will create a 3 nodeType service fabric environment FrontEnd, Backend and Management nodeTypes.

The management node type is set as the Primary.

Note the NSG’s are not assigned to the Subnet but they are created by the script.

Go to folder:

secureTemplateAnd3NodeTypeWithApplicationGatewayAndExistingSubnet

Copy the parameters.json file and then change the parameters.

Note: By default the script creates the minimum number of VM’s all at Standard A0 size. If this is a non-development environment you will want to change the VM size to be:

· Minimum number of instances:

o Set to 5 on Management/Primary node type

o Set to 5 on Backend node type (stateful)

o Set to 2 on Frontend node type (stateless)

· Size (set to Standard D1_V2 the minimum supported spec for all node types)

· Reliability Level of the cluster should be minimum of Silver in production (default is Bronze)

o Static IP parameters (change to match those you just setup):

existingStaticIPResourceGroup
existingStaticIPName
existingStaticIPDnsFQDN

o Specifiy the existing Virtual network and subnet names:

virtualNetworkName
existingVNetRGName
subnet0Name
subnet1Name
subnet2Name
subnetWAFName

o Active Directory parameters (change to match those you just setup):

aadTenantId
aadClusterApplicationId
aadClientApplicationId

o Certificate parameters (change to match those you just setup):

SourceVaultValue
certificateUrlValue
certificateThumbprint

o VM login parameters (used if you ever need to RDP into a cluster machine):

adminUserName
adminPassword

o Other parameters

Execute the deploy script:

.\deploy.ps1 -subscriptionId <yourAzureSubscriptionIdHere> -resourceGroupName mycluster -deploymentName mycluster -parametersFilePath .\parameters.json

If after a long time it errors with this message ‘Monitoring Agent not reporting success after launch’

Then you should be fine as Service Fabric will automatically recover the nodes that this failed for.

3. After deployment

Go to the Azure portal and find your service fabric cluster and you should eventually see the nodes (they may take some time to appear).

Once the deployment has finished and you can see in the Azure Portal that the nodes in the cluster are running you should be able to view the cluster e.g.

https://jonscluster.northeurope.cloudapp.azure.com:19080/Explorer

This should prompt you to login. If you see a message:

AADSTS50105: The signed in user 'jon.lanceley_xxxxxxxxx.com#EXT#@jonlanceleyxxxxxxxx.onmicrosoft.com' is not assigned to a role for the application '9df93f43-6682-4004-addd-1522a4e13439'.

Go to Azure Active Directory -> Enterprise Applications -> All Applications

Find the cluster server application (not the client one)

Add the user as an Admin

That’s it, you should now have a running Service Fabric Cluster.

You now just need to deploy some code to it. And then open the Front End Internal load balancer and the Application Gateway ports for the application: http://jonlanceley.blogspot.co.uk/2017/04/setup-application-gateway-internal.html

Release Management in TFS 2015.2

2016-04-12T06:08:00.001+00:00

With the TFS 2015.2 update we now have the ability to use Release Manager in TFS on premise. This is how I have setup our branching structure, gated check-in and release manager to control the deployment (with approvals at some stages) of an MVC5 web site with Entity Framework into multiple Azure Web Application environments.

We have our branching structure set as:

Dev\developer name 1

Dev\developer name 2 etc

Main

Developers take a branch from main into the dev folder under their name and work on changes. When development is complete they check-in to their dev branch and then merge the changes into the Main branch. This allows the developer to pull in other changes from main into their dev branch, and be able to check-in at least daily into their dev branch so their code is backed up overnight.

We are using the new TFS build tasks; and setup against the Main branch is:

A gated check-in.

And a number of build tasks that compile the code in Release mode, run some unit tests and finally copy the files/build artifacts we need to deploy the web site into the drop folder (essentially a web deploy zip file is created).

The key to creating a web deploy zip file is the MS Build Arguments:

/p:DeployOnBuild=true /p:WebPublishMethod=Package /p:PackageAsSingleFile=true /p:SkipInvalidConfigurations=true

In the copy and Publish build artifacts task we have:

This automatically builds all changes checked into the Main branch with the final step it produces the web deploy files. Assuming the build passes then Release Manager will take over to deploy the web site into an Azure Web Application.

We have 4 environments in Azure that we need to deploy to ‘UAT Staging’, ‘UAT’, ‘Production Staging’ and ‘Production’. For us these are split into 2 Azure subscriptions, one for UAT one for Production. Within each subscription is 1 web application e.g. UAT and against that 1 slot ‘staging’ and each has its own Azure SQL database. This gives us 2 websites and 2 databases. We make use of sticky slot settings as well so the connection string / app settings stay against its environment because in production we make use of the Azure web application swap slot functionality.

So we configure release manager to deploy the code to UAT staging, UAT and Production staging. But for production release manager just initiates a swap slot PowerShell command.

So in Release manager we will need to setup the deployment process or tasks for each of these environments.

But first Release manager is setup to watch the main branch for a new build artifact which is done by setting the release trigger to Continuous Deployment.

As soon as a new version is checked in setting the UAT Staging environment trigger to ‘Automated after release creation’ will initiate a deployment into that environment automatically (and for us with no approvals required because that is the first server in Azure which our developers can test against).

On the environments tab we define the deployment steps for each environment so for UAT Staging we have:

Stop the Azure web application
Deploy the new code/web site
Start the Azure web application

We are making use of the new TFS Market Place extension ‘Run Inline Azure Powershell’ task which allows us to stop the Azure web application with:

Stop-AzureWebsite -Name $(WebAppName) -Slot stage

And below are the properties of the Azure Web App Deployment task, with the main one being the path to the Web Deploy Package.

Note: Our web applications are always running in Azure we are not creating them on demand.

The UAT and Production Staging environments all have the same 3 tasks. Deployment into an environment takes about 1 minute 20 seconds.

The Production environment has 1 task which swaps Production Staging with Production by executing this powershell script:

Switch-AzureWebsiteSlot -Name $(WebAppName) -Slot1 stage -Slot2 production -Force -Verbose

That allows us to do a quick production deployment (saving us that 1 minute 20).

UAT, Production Staging and Production all have Pre-Deployment approvers setup.

So deployment to the 1^st Azure environment ‘UAT Staging’ happens automatically upon a successful check-in to the Main branch.

The developer has the chance now to manually test the site. When they want to deploy to the next environment ‘UAT’ they would open the release in release manager and start the deployment:

By using the ‘Deploy’ button to request the code is deployed into the UAT environment this will send an email to the approvers who will ‘hopefully’ approve the release and if they do release manager will execute the 3 deployment tasks setup for the UAT environment.

The same process would be followed for the remaining environments, the developer tests then uses the deploy button to move the same web application code to the next environment.

At any point we can check what release is in what environment by looking at the overview tab.

Database changes are done via Entity Framework Code First Migrations which are executed upon web site start up by running this code added to the MVC site startup.cs class:

var efConfiguration = new Configuration();

var dbMigrator = new System.Data.Entity.Migrations.DbMigrator(efConfiguration);

dbMigrator.Update();

This will execute any schema changes and then run the seed data method. The key to keeping the seed data updated is using the extension method ‘AddOrUpdate’.

Useful Links

https://msdn.microsoft.com/library/vs/alm/release/overview

Unit Testing (part 4) - Faking Entity Framework code first DbContext & DbSet

2015-08-30T12:53:00.001+00:00

This is the 4^th in a series of posts about unit testing:

Unit Testing (part 1) - Without using a mocking framework

Unit Testing (part 2) - Faking the HttpContext and HttpContextBase

Unit Testing (part 3) - Running Unit Tests & Code Coverage

Unit Testing (part 4) - Faking Entity Framework code first DbContext & DbSet

Following on from the last 3 articles we can use the same approach of faking with test doubles on our database repository methods.

I’m using Entity Framework 6 code first and I want to be able to call the code in my repository layer so I can test the where clauses etc, but I do not want to actually call the database. Entity framework has a DBContext and a DbSet we just need to fake them.

All of our model properties implement this interface IDbEntity.

public interface IDbEntity<TPrimaryKey>

{

/// <summary>

/// Unique identifier for this entity.

/// </summary>

TPrimaryKey ID { get; set; }

}

What this does is say we must have a primary key called ID on each model. We will use this later to implement a fast generic DbSet Find method.

public class Country : IDbEntity<Int32>

{

[Key, DatabaseGenerated(DatabaseGeneratedOption.None)]

public Int32 ID { get; set; }

[Required]

[MaxLength(100)]

public String Name { get; set; }

}

First we need to setup our DbContext so we start with our interface which just contains a list of DbSet’s (which is what we need in order to begin faking it for the unit tests).

public interface ISiteDBContext

{

DbSet<Country> Countries { get; set; }

}

Our concrete class that the MVC web site uses looks like this:

public class SiteDBContext : DbContext, ISiteDBContext

{

public SiteDBContext()

: base()

{

// Disable database initialisation (e.g. when the site is first run)

Database.SetInitializer<SiteDBContext>(null);

}

public SiteDBContext(string nameOrConnectionString)

: base(nameOrConnectionString)

{

// Disable database initialisation (e.g. when the site is first run)

Database.SetInitializer<SiteDBContext>(null);

}

public DbSet<Country> Countries { get; set; }

protected override void OnModelCreating(DbModelBuilder modelBuilder)

{

// Fluent API commands go here e.g.

modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();

modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();

base.OnModelCreating(modelBuilder);

}

And our fake one for unit testing looks like this (note the differences in yellow). We are implementing the interface but then in the constructor setting the Country DbSet to use our FakeDbSet instead:

public class FakeSiteDBContext : DbContext, ISiteDBContext

{

public FakeSiteDBContext() : base()

{

// Disable code first auto creation of a database

Database.SetInitializer<FakeSiteDBContext>(null);

Countries = new FakeDbSet<Country>();

}

public DbSet<Country> Countries { get; set; }

public override DbSet<TEntity> Set<TEntity>()

{

foreach (PropertyInfo property in

typeof(FakeSiteDBContext).GetProperties())

{

if (property.PropertyType == typeof(DbSet<TEntity>))

{

var value = property.GetValue(this, null) as DbSet<TEntity>;

return value;

}

// If the above fails fall back to the base default

return base.Set<TEntity>();

}

And this is the FakeDbSet:

public sealed class FakeDbSet<TEntity> : DbSet<TEntity>, IQueryable, IEnumerable<TEntity>, IDbAsyncEnumerable<TEntity>

where TEntity : class

{

ObservableCollection<TEntity> _data;

IQueryable _query;

public FakeDbSet()

{

_data = new ObservableCollection<TEntity>();

_query = _data.AsQueryable();

}

public override TEntity Find(params object[] keyValues)

{

// Find by the Primary Key (ID) as defined in the interface IDbEntity

// which is set on all of our model classes. This is a fast generic way to

// implement find.

// There is only currently 1 primary keyValue that can be passed in so we

// use [0] to find it

var result = _data.OfType<IDbEntity<Int32>>().Where(m => m.ID ==

(Int32)keyValues[0]);

var myEntity = (TEntity)result.SingleOrDefault();

return myEntity;

}

public override TEntity Add(TEntity item)

{

// In our FakeDbSet when an item is added to the context we increment it's

// primary Key (ID column) otherwise it will always be 0

// All our model classes inherit IDbEntity which defines an ID column as

// the primary key

// But note this will not update navigation properties, apperently there

// is no way in EF to do that yet (so you have to work around it)

if (item is IDbEntity<Int32>)

{

var myItem = (IDbEntity<Int32>)item;

if (myItem.ID == 0)

{

// Get the last record entered, so we can get it's ID then add 1

// to it for the new record

var lastItem = _data.LastOrDefault();

if (lastItem == null)

myItem.ID = 1;

else

{

var myLastItem = (IDbEntity<Int32>)lastItem;

myItem.ID = myLastItem.ID + 1;

}

_data.Add(item);

return item;

}

public override TEntity Remove(TEntity item)

{

_data.Remove(item);

return item;

}

public override TEntity Attach(TEntity item)

{

_data.Add(item);

return item;

}

public override TEntity Create()

{

return Activator.CreateInstance<TEntity>();

}

public override TDerivedEntity Create<TDerivedEntity>()

{

return Activator.CreateInstance<TDerivedEntity>();

}

public override ObservableCollection<TEntity> Local

{

get { return _data; }

}

Type IQueryable.ElementType

{

get { return _query.ElementType; }

}

Expression IQueryable.Expression

{

get { return _query.Expression; }

}

IQueryProvider IQueryable.Provider

{

get { return new TestDbAsyncQueryProvider<TEntity>(_query.Provider); }

}

System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()

{

return _data.GetEnumerator();

}

IEnumerator<TEntity> IEnumerable<TEntity>.GetEnumerator()

{

return _data.GetEnumerator();

}

IDbAsyncEnumerator<TEntity> IDbAsyncEnumerable<TEntity>.GetAsyncEnumerator()

{

return new TestDbAsyncEnumerator<TEntity>(_data.GetEnumerator());

}

internal class TestDbAsyncQueryProvider<TEntity> : IDbAsyncQueryProvider

{

private readonly IQueryProvider _inner;

internal TestDbAsyncQueryProvider(IQueryProvider inner)

{

_inner = inner;

}

public IQueryable CreateQuery(Expression expression)

{

return new TestDbAsyncEnumerable<TEntity>(expression);

}

public IQueryable<TElement> CreateQuery<TElement>(Expression expression)

{

return new TestDbAsyncEnumerable<TElement>(expression);

}

public object Execute(Expression expression)

{

return _inner.Execute(expression);

}

public TResult Execute<TResult>(Expression expression)

{

return _inner.Execute<TResult>(expression);

}

public Task<object> ExecuteAsync(Expression expression, CancellationToken cancellationToken)

{

return Task.FromResult(Execute(expression));

}

public Task<TResult> ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken)

{

return Task.FromResult(Execute<TResult>(expression));

}

internal class TestDbAsyncEnumerable<T> : EnumerableQuery<T>, IDbAsyncEnumerable<T>, IQueryable<T>

{

public TestDbAsyncEnumerable(IEnumerable<T> enumerable)

: base(enumerable)

{ }

public TestDbAsyncEnumerable(Expression expression)

: base(expression)

{ }

public IDbAsyncEnumerator<T> GetAsyncEnumerator()

{

return new TestDbAsyncEnumerator<T>(this.AsEnumerable().GetEnumerator());

}

IDbAsyncEnumerator IDbAsyncEnumerable.GetAsyncEnumerator()

{

return GetAsyncEnumerator();

}

IQueryProvider IQueryable.Provider

{

get { return new TestDbAsyncQueryProvider<T>(this); }

}

internal class TestDbAsyncEnumerator<T> : IDbAsyncEnumerator<T>

{

private readonly IEnumerator<T> _inner;

public TestDbAsyncEnumerator(IEnumerator<T> inner)

{

_inner = inner;

}

public void Dispose()

{

_inner.Dispose();

}

public Task<bool> MoveNextAsync(CancellationToken cancellationToken)

{

return Task.FromResult(_inner.MoveNext());

}

public T Current

{

get { return _inner.Current; }

}

object IDbAsyncEnumerator.Current

{

get { return Current; }

}

Then using dependency injection in your unit test you register the FakeSiteDBContext. Using Unity it would be:

container.RegisterType<DbContext, FakeSiteDBContext>(new PerRequestLifetimeManager());

And in the website you’d do:

container.RegisterType<DbContext, SiteDBContext>(new PerRequestLifetimeManager());

The unit test would look like this, in this example I’m calling a basketService method which would do all the same calls as if we were running the MVC web site, except in the test it is going to call our FakeDbSet and FakeDbSiteContext to avoid hitting a database because that’s what we told our dependency injection to do swap out every instance of DbContext with our FakeSiteDBContext.

[TestMethod]

public void AddToBasket_AddUSDItemToNewBasket()

{

HttpContext.Current = new FakeHttpContext().CreateFakeHttpContext();

unityContainer = UnityConfig.GetConfiguredContainer();

var basketService = unityContainer.Resolve<IBasketService>();

var httpContextWrapper = new FakeHttpContextWrapper(httpContext:

HttpContext.Current);

var model = basketService.AddSubscriptionItemToBasket(httpContextWrapper, params go here…);

Assert.AreEqual("en-US", model.CurrencyFormat.CurrencyCulture, "CurrencyCulture");

}

If you wanted to you can also seed the entity framework models with the same seed data you’d use in the real database, remember it’s all in memory and it’s fast. It’s also useful as your working with the same data rather than creating fake data for every test.

There is nothing stopping you creating specific test data for one test as well, all you have to do is add populated models to the Entity Framework DbContext at the start of a unit test.

var order = new Order()

{

UserBasketID = userBasketId,

OrderItems = new Collection<OrderItem>(),

DateCreated = DateTime.Now

};

var orderItem1 = new OrderItem

{

Price = 2.00M,

Quantity = 1,

DateCreated = DateTime.Now,

Order = order

};

order.OrderItems.Add(orderItem1);

dbContext.Orders.Add(order);

dbContext.OrderItems.Add(orderItem1);

No need to save (remember it’s in memory all you have to do is .Add).

The only downside with this approach I’ve found so far are your site will run but the tests may fail because:

Navigation property might = null.
Not all the data is added to the context.

Remember we are faking out the DbContext and DbSet so we do not get all the Entity Framework functionality.

To address both of these points:

If you have reference/navigation properties make sure you set them like the ones in yellow above (we assign the order to the orderItem). This way your repository methods navigation properties will work in your unit test and won’t be null.
If you think back to EF v1 days you had to add the items to the context that you want to save. So in the example above EF would be fine with just the dbContext.Orders.Add(order) line it would know there are orderItems that also need saving. But the fake DbContext won’t! So if we are testing a lookup directly for orderItems our test would show 0 records.

We just have to also attach the orderItems to the dbContext too. It won’t affect the way the site runs and our tests will pass. So there is a compromise to be made here but in my opinion a small one. Some people will argue that we are changing our site code to make the tests pass, and yes we are (slightly and only when we hit this scenario which has not happened to me much so far).

You should always follow up with UI integration tests such as Selenium, Microsoft’s Coded UI etc to test all the site functions and 3^rd party calls work, these will be slower, but at least now we’ve got a way to run lots of fast unit tests before the code leaves Visual Studio.

Using this approach here are just some of my unit tests so you can see how quick they are:

Unit Testing (part 3) – Running unit tests & code coverage

2015-08-30T12:52:00.001+00:00

This is the 3^rd in a series of posts about unit testing:

Unit Testing (part 1) - Without using a mocking framework

Unit Testing (part 2) - Faking the HttpContext and HttpContextBase

Unit Testing (part 3) - Running Unit Tests & Code Coverage

Unit Testing (part 4) - Faking Entity Framework code first DbContext & DbSet

The new way of running unit tests from within Visual Studio or as part of a TFS build is by making use of the TestSettings.RunSettings file (the old file was TestSettings.TestSettings).

This is the TestSettings.RunSettings file from Microsoft with our exclusions added to it in yellow.

What this does is when the code coverage tool is run it excludes certain code from that process such as the code first migrations files or 3^rd party DLL’s (as we cannot unit test them) so we need to exclude them otherwise our code coverage stats will never reach or get close to 100%!.

<?xml version="1.0" encoding="utf-8"?>

<!--

Additional paths to search for .pdb (symbol) files. Symbols must be found for modules to be instrumented.

If .pdb files are in the same folder as the .dll or .exe files, they are automatically found. Otherwise, specify them here.

Note that searching for symbols increases code coverage runtime. So keep this small and local.

-->

<!--

<Path>C:\Users\User\Documents\Visual Studio 2012\Projects\ProjectX\bin\Debug</Path>

<Path>\\mybuildshare\builds\ProjectX</Path>

</SymbolSearchPaths>

-->

<!--

About include/exclude lists:

Empty "Include" clauses imply all; empty "Exclude" clauses imply none.

Each element in the list is a regular expression (ECMAScript syntax). See http://msdn.microsoft.com/library/2k3te2cs.aspx.

An item must first match at least one entry in the include list to be included.

Included items must then not match any entries in the exclude list to remain included.

-->

</Include>

<ModulePath>.*CPPUnitTestFramework.*</ModulePath>

<ModulePath>.*stackexchange.*</ModulePath>

<ModulePath>.*antlr3.*</ModulePath>

<ModulePath>.*microsoft.practices.*</ModulePath>

</Exclude>

</ModulePaths>

<Function>^Fabrikam\.UnitTest\..*</Function>

<Function>.*::__GetTestMethodInfo.*</Function>

<Function>^Microsoft::VisualStudio::CppCodeCoverageFramework::.*</Function>

<Function>^Microsoft::VisualStudio::CppUnitTestFramework::.*</Function>

<Function>^SiteDataAccess\.Core\.Migrations\..*</Function>

</Exclude>

</Functions>

<Attribute>^System.Diagnostics.DebuggerHiddenAttribute$</Attribute>

<Attribute>^System.Diagnostics.DebuggerNonUserCodeAttribute$</Attribute>

<Attribute>^System.Runtime.CompilerServices.CompilerGeneratedAttribute$</Attribute>

<Attribute>^System.CodeDom.Compiler.GeneratedCodeAttribute$</Attribute>

<Attribute>^System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute$</Attribute>

</Exclude>

</Attributes>

<Source>.*\\atlmfc\\.*</Source>

<Source>.*\\vctools\\.*</Source>

<Source>.*\\public\\sdk\\.*</Source>

<Source>.*\\microsoft sdks\\.*</Source>

<Source>.*\\vc\\include\\.*</Source>

</Exclude>

</Sources>

<CompanyName>.*microsoft.*</CompanyName>

</Exclude>

</CompanyNames>

</Exclude>

</PublicKeyTokens>

<CollectAspDotNet>False</CollectAspDotNet>

</CodeCoverage>

</Configuration>

</DataCollector>

</DataCollectors>

</DataCollectionRunSettings>

</RunSettings>

Save this file and then in Visual Studio go to Test -> Test Settings and select this .RunSettings file. And then run the tests.

If you have Visual Studio Enterprise you can automatically run the tests on every build by clicking this icon

We should be running the unit tests frequently and before we merge our code to the main branch.

To use Code Coverage (again an Enterprise thing) Right click in test explorer and choose ‘Analyze Code Coverage for Selected Tests’.

All the tests will then be run and the ‘Code Coverage Results’ window will appear.

Clicking the icon circled above will show all your code highlighted so at a glance as you navigate your code you can see what is covered by the unit tests.

· Blue = Unit tests are testing it

· Red = No tests are testing this code yet!

We should be running code Analysis before we merge to main to ensure our code is being tested.

Using the same .RunSettings file on a TFS build shows this:

And in the TFS Build Summary report:

(Note: I only have code coverage and unit tests’ running on main branch merges.)

Unit Testing (part 2) - Faking the HttpContext and HttpContextBase

2015-08-30T12:50:00.001+00:00

This is the 2^nd in a series of posts about unit testing:

Unit Testing (part 1) - Without using a mocking framework

Unit Testing (part 2) - Faking the HttpContext and HttpContextBase

Unit Testing (part 3) - Running Unit Tests & Code Coverage

Unit Testing (part 4) - Faking Entity Framework code first DbContext & DbSet

There are a lot of posts on the internet about faking the http context. And when we have controllers / service functions / MVC routes that all make use of the HttpContext how do you fake it.

This is my approach which works consistently across all my tests. I went down a route initially of having different ways of handling a HttpContext vs a HttpContextBase. And then I found way to have 1 approach so the tests are consistent.

First we need a way to fake a normal HttpContext.

public class FakeHttpContext

{

public HttpContext CreateFakeHttpContext()

{

var httpRequest = new HttpRequest("", "http://localhost/", "");

var stringWriter = new StringWriter();

var httpResponce = new HttpResponse(stringWriter);

var httpContext = new HttpContext(httpRequest, httpResponce);

var sessionContainer = new HttpSessionStateContainer("id",

new SessionStateItemCollection(),

new HttpStaticObjectsCollection(),

10,

true, HttpCookieMode.AutoDetect, SessionStateMode.InProc, false);

SessionStateUtility.AddHttpSessionStateToContext(httpContext, sessionContainer);

return httpContext;

}

Secondly we need a way to fake HttpContextBase.

MVC already have this covered with their implementation of HttpContextWrapper. But unfortunately even this doesn’t go quite far enough especially when you want to unit test MVC routes. But we can extend it, enter our FakeHttpContextWrapper. This inherits from Microsoft’s HttpContextWrapper.

What this is going to do is allow us to create our own fake classes by extending the Microsoft ones (so we don’t have to reinvent the wheel). And this will now let us over-ride the properties we need for unit testing.

We first create a FakeHttpContextWrapper which contains our FakeHttpRequestWrapper, and could also contain a FakeHttpResponseWrapper if we needed it. I’ve commented out the FakeHttpResponseWrapper as I didn’t need it but it does work if you uncomment it.

public class FakeHttpContextWrapper : HttpContextWrapper

{

FakeHttpRequestWrapper _request;

//FakeHttpResponseWrapper _response;

public FakeHttpContextWrapper(HttpContext httpContext)

: base(httpContext)

{

_request = new FakeHttpRequestWrapper(httpContext.Request);

//_response = new FakeHttpResponseWrapper(httpContext.Response);

}

public FakeHttpContextWrapper(HttpContext httpContext, string appPath = "/",

string requestUrl = "~/", string clientIP = null)

: base(httpContext)

{

_request = new FakeHttpRequestWrapper(httpContext.Request, appPath, requestUrl, clientIP);

//_response = new FakeHttpResponseWrapper(httpContext.Response);

}

/// <summary>

/// Over-ridden so we can return our FakeHttpRequestWrapper class instead

/// </summary>

public override HttpRequestBase Request

{

get

{

return _request;

}

public override HttpResponseBase Response

{

get

{

//return _response;

return base.Response;

}

We then create a FakeHttpRequestWrapper which inherits from the Microsoft HttpRequestWrapper. This is where the magic happens as this allows us to over-ride those getter properties ApplicationPath, AppRelativeCurrentExecutionFilePath and UserHostAddress so we can implement our own logic.

/// <summary>

/// This class allows us to set additional properties that are anoyingly null by

/// default if you just used the HttpRequestWrapper class alone.

/// We are over-ridding the ApplicationPath & AppRelativeCurrentExecutionFilePath

/// as these are needed to unit test MVC routes

/// </summary>

public class FakeHttpRequestWrapper : HttpRequestWrapper

{

string appPath;

string requestUrl;

string clientIP;

public FakeHttpRequestWrapper(HttpRequest httpRequest)

: base(httpRequest)

{

}

public FakeHttpRequestWrapper(HttpRequest httpRequest, string appPath = "/",

string requestUrl = "~/", string clientIP = null)

: base(httpRequest)

{

this.appPath = appPath;

this.requestUrl = requestUrl;

this.clientIP = clientIP;

}

public override string ApplicationPath

{

get

{

return appPath;

}

public override string AppRelativeCurrentExecutionFilePath

{

get

{

return requestUrl;

}

public override string UserHostAddress

{

get

{

return clientIP;

}

I didn’t need to fake the response but this is how you’d do it if you need to:

public class FakeHttpResponseWrapper : HttpResponseWrapper

{

public FakeHttpResponseWrapper(HttpResponse httpResponse)

: base(httpResponse)

{

}

In this unit test you can see 2 lines that deal with setting the HttpContext.

[TestMethod]

public void ProductService_PopulateModel_IPDetectUSA()

{

var clientIP = "1.1.1.2";

var productService = unityContainer.Resolve<IProductService>();

HttpContext.Current = new FakeHttpContext().CreateFakeHttpContext();

var httpContextWrapper = new FakeHttpContextWrapper(httpContext:

HttpContext.Current,

clientIP: clientIP);

var model = productService.PopulateModel(httpContextWrapper);

}

The 1^st line sets a normal HttpContext.Current using our FakeHttpContext () method.

The 2^nd line uses our FakeHttpContextWrapper method to wrap and extend the HttpContext.Current we set up on the 1^st line which is something we can now pass to MVC controllers or routes.

And this is how you’d unit test an MVC route (the clientIP and requestUrl parameters are optional).

[TestMethod]

public void Route_Account_Login()

{

var routes = new RouteCollection();

RouteConfig.RegisterRoutes(routes);

HttpContext.Current = new FakeHttpContext().CreateFakeHttpContext();

var httpContextWrapper = new FakeHttpContextWrapper(httpContext:

HttpContext.Current,

requestUrl: "~/account/login/");

var routeData = routes.GetRouteData(httpContextWrapper);

//Expected Results

AssertAll.Execute(() => Assert.IsNotNull(routeData),

() => Assert.AreEqual("Account", (string)routeData.Values["controller"], true),

() => Assert.AreEqual("login", (string)routeData.Values["action"], true),

() => Assert.IsTrue(string.IsNullOrWhiteSpace(routeData.Values["id"].ToString())));

}

And this is how you would test an MVC controller, using the same 2 lines in yellow just without the optional parameter this time.

[TestMethod]

public void ProductController_CheckView()

{

var productService = unityContainer.Resolve<IProductService>();

var productController = new ProductController(productService);

HttpContext.Current = new FakeHttpContext().CreateFakeHttpContext();

var httpContextWrapper = new FakeHttpContextWrapper(httpContext:

HttpContext.Current);

// Pass the fake httpContext to the controller context

productController.ControllerContext = new ControllerContext(httpContextWrapper, new

RouteData(), productController);

// Call the controller method to test

var controllerResult = productController.Index();

// Check the view name is correct

Assert.IsTrue(controllerResult is ViewResult, "ViewResult");

var view = controllerResult as ViewResult;

Assert.AreEqual("Index", view.ViewName, "ViewName");

}

Unit Testing (part 1) - Without using a mocking framework

2015-08-30T12:47:00.001+00:00

In this series of posts we are not using Moq or Microsoft Fakes or any testing framework, instead we are using the test double approach and following the rule “do not test code you do not own”.

Unit Testing (part 1) - Without using a mocking framework

Unit Testing (part 2) - Faking the HttpContext and HttpContextBase

Unit Testing (part 3) - Running Unit Tests & Code Coverage

Unit Testing (part 4) - Faking Entity Framework code first DbContext & DbSet

When I asked myself what I needed to test the answer is “my business logic and any classes I wrote that are called by the business logic”. I don’t want to test making actual calls to the database or 3^rd party web services etc.

I also took the view that what I wanted to test was not every class in isolation I don’t have the time at my employer to do it the purist way of mocking the in’s/outs around each class. Instead I came up with a compromise and call the controller and let the code run (as it would when running on the web site). I just fake out the 3^rd party calls so my focus of testing is on my code.

Let’s see how this works:

The MVC 5 web site controllers in my site don’t really contain any code they all reference a service function which populates the MVC model. Which keep our controllers lean.

public ProductController(IProductService productService) : base()

{

this.productService = productService;

}

public ActionResult Index()

{

var model = productService.PopulateModel(this.HttpContext, ...);

return View(model.ViewTemplateToRender, model);

}

We make use of Interfaces (which are essential for effective unit testing).
Also note that the PopulateModel(this.HttpContext, …) is expecting a HttpContextBase more on that later.
We use dependency injection to inject the actual concrete class at run time which matches the interface. We do this so in our unit tests we can over-ride any concrete class and replace it with a test double if we need to. The times when we would do this are when we call code that we do not own (e.g. 3^rd party web services, .Net framework code etc.).

This is where the rule “do not test code you do not own” comes into its own.

By not following this rule you open yourself to a whole world of pain. For example why test a call to an external web service. All you need to do is test that your code is calling the correct method, passing the correct data, and getting back the correct response. But without making the actual call we’d fake it instead. This results in tests that run much faster. If you made the call to the web service that’s integration testing.

Why would you test code that sets a cookie, you’ve got to fake the request / response to do it, we know it works Microsoft have tested it, and it’s been in .Net for many years. It’s actually much easier to test if you think differently and use a CookieContainer class with an interface ICookieContainer then I let the site use request.Cookies etc. And have a test double FakeCookieContainer class that doesn’t use the request / response at all.

Let’s say I had an external web service which one of my service functions calls which given the clients IP number returns the country that the IP number is located in. I do not want to make that actual call from a unit test the speed will be terrible and that’s a job for an integration test using Selenium or some other UI testing tool. But I do want to call it from my website. So I create an interface:

public interface IIpFunctions

{

Country GetCountry(HttpRequestBase request);

}

My concrete class used by the site is going to call the GetCountry method and do the actual calling of the external web service, which would look like this (some code has been removed for simpler reading):

public class IpFunctions : IIpFunctions

{

public Country GetCountry(HttpRequestBase request)

{

String ip = GetClientIP(request);

using (HttpClient client = new HttpClient())

{

HttpResponseMessage response = client.GetAsync(countryRequest).Result;

response.EnsureSuccessStatusCode();

countryResult = response.Content.ReadAsStringAsync().Result;

}

return countryRepository.GetByIso(countryResult);

}

For unit testing I just need to create a fake concrete class, both inheriting the same interface. So it passes in the same request object and gets a Country object back. But the code internally is very different.

public class FakeIpFunctions : IIpFunctions

{

public Country GetCountry(HttpRequestBase request)

{

var clientIP = request.UserHostAddress;

if (clientIP == "1.1.1.1")

{

// Fake UK IP address

return countryRepository.GetByIso("GBR");

}

else if (clientIP == "1.1.1.2")

{

// Fake USA IP address

return countryRepository.GetByIso("USA");

}

return null;

}

Now when I’m writing a unit test I can just pass in the IP number 1.1.1.2 as part of the request object and I know the country will be USA.

My unit test would look like this:

[TestMethod]

public void ProductService_PopulateModel_IPDetectUSA()

{

var clientIP = "1.1.1.2";

var productService = unityContainer.Resolve<IProductService>();

HttpContext.Current = new FakeHttpContext().CreateFakeHttpContext();

var httpContextWrapper = new FakeHttpContextWrapper(httpContext: HttpContext.Current, clientIP: clientIP);

var model = productService.PopulateModel(httpContextWrapper);

}

My dependency injection is setup so:

It uses the same IProductService concrete class for unit tests and for the MVC web site. But within the ProductService class’s constructor it uses the IIpFunctions interface.

public ProductService(IIpFunctions ipFunctions, …)

For the IIpFunctions interface the dependency injection is very different, the site calls IpFunctions and the unit tests call FakeIpFunctions.

So I’ve followed the rule “don’t test what you don’t own”. I can do the same with cookies, cache managers like Redis Cache etc. I don’t want to test third party code, so I use interfaces and create a fake test double class for unit testing with.

Note: in the above unit test example I’m starting my unit test at my ProductService not the MVC controller, there is no reason this could not be the controller but because my controllers don’t really contain any code they simply call the service layer I decided that my unit tests for the most part should start at the service layer. I’d then need just a handful of unit tests to test the controller (which would really be to just check the correct view is being returned or any viewbag values are set correctly etc.).

Is this the purist way of doing unit testing – No.

Is this truly a unit test where the definition of a unit = a class (e.g. you test each class in isolation and any dependencies for it are mocked / faked) – No.

Isn’t this integration testing – That’s a fine line and debatable but no because it’s very fast, all in memory and we don’t call 3^rd party code/services like an integration test would.

Why didn’t we do the above?

Because companies don’t like to invest the time in developing unit tests especially the purist way. So it’s better to have something rather than nothing.
Because it would take a lot longer to write and more tests are needed to get decent code coverage.
It gives the same benefit; the code is tested very quickly while it’s still in Visual Studio. And we’d always follow up with integration tests once the code has been deployed to a test environment.

Http to Https Flipper for Asp.Net Web Forms

2011-07-02T09:42:00.001+00:00

This article shows how to automatically make Asp.Net Web Form sites open certain pages on the site as https by using a 301 moved permanently redirect. It works with standard web forms .aspx pages and web forms using .Net Routing.

This example will cover the following scenarios:

1. If a user navigates to http://www.mydomain.com/default.aspx then we can automatically have the URL change to be https://www.mydomain.com/default.aspx for the default.aspx page only, other pages will remain non-secure.

2. You want all your sites web pages to always go secure (https).

3. Allow you to control which pages go secure by using a ‘RequireSSL’ attribute (much like mvc now does).

4. Allow you to control which pages go secure by listing them in the web.config.

5. If you have non standard ports for http and https e.g. http://www.mydomain.com:8054/default.aspx can change the URL to https://www.mydomain.com:4054/default.aspx.

Note the 8054 = http and 4054 = https.

6. You have non standard ports as point 5 above mentions, but in your live environment the ports are masked from the user by the firewall (or some other clever piece of hardware). But internally the ports are still being used by the firewall to route traffic to your site.

e.g. Your web site on IIS is setup to use ports 8054(http) & 4054(https) but the user in their browser will see http://www.mydomain.com/default.aspx and https://www.mydomain.com/default.aspx. In this scenario you would want to remove the port when you flip from http to https.

Lets see some code

First create a new project, lets call it ‘JL.Web.Security’.

As you add the classes below the structure of the project should end up looking like the above.

Add the following 2 classes (RequireSSLAttribute.cs and RequireSSLModule.cs).

RequireSSLAttribute.cs

namespace JL.Web.Security
{
    /// <summary>
    /// Attribute to place on classes that you want to go secure (SSL / HTTPS)
    /// </summary>
    [AttributeUsage(AttributeTargets.Class)]
    sealed public class RequireSSL : Attribute
    {
    }
}

With the ‘RequireSSLAttribute’' you can now place this attribute on any web form code behind page and that page will always go secure e.g.

namespace WebApplication
{
    [RequireSSL]
    public partial class WebForm1 : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
        }
    }
}

The ‘RequireSSLModule.cs’ class below is the one that does the real work.

But in summary all this class really does is create a new IHttpModule that listens for page requests. Then checks if every page should be secure and if we are not already secure then go secure (https). Otherwise check if the RequireSSL attribute is on the page if it is go secure (if we are not secure already), if the attribute is not in use then check the web.config file to see if the page is listed there, if it is go secure (if we are not secure already). Otherwise go non secure (if we are currently secure).

RequireSSLModule.cs

namespace JL.Web.Security
{
    /// <summary>
    /// HttpModule for switching between HTTP and HTTPS (HTTP <=> HTTPS)
    /// </summary>
    public class RequireSSLModule : IHttpModule
    {
        SecureWebPageSettings settings = null;

        public void Init(HttpApplication context)
        {
            settings = WebConfigurationManager.GetSection("secureWebPageSettings") as SecureWebPageSettings;
            if (settings != null && settings.Mode != SecureWebPageMode.Off)
            {
                // The PreRequestHandlerExecute event occurs just before ASP.NET begins executing
                // a handler such as a Page.
                // In here we can acquire a reference to the currently executing ASPX Page
                context.PreRequestHandlerExecute += new EventHandler(OnPreRequestHandlerExecute);
            }
        }

        /// <summary>
        /// Empty, but necessary when implementing IHttpModule
        /// </summary>
        public void Dispose() { }

        /// <summary>
        /// Switch between HTTP and HTTPS as and when necessary.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void OnPreRequestHandlerExecute(object sender, EventArgs e)
        {
            bool requireSSL = false;

// obtain a reference to the ASPX Page
System.Web.UI.Page Page = HttpContext.Current.Handler as System.Web.UI.Page;

            // if a valid Page was not found, exit
            if (Page == null)
            {
                return;
            }

            if (settings.MakeAllPagesSecure)    // All pages must be secure
                requireSSL = true;
            else
            {
                // Check if the Page is decorated with the RequireSSL attribute
                requireSSL = (Page.GetType().GetCustomAttributes(typeof(RequireSSL), true).Length > 0);
                if (requireSSL == false)
                {
                    // Check the pages in the web.config to see if it is mentioned here as must be secure
                    var pageName = Page.GetType().BaseType.Name;
                    if (settings.Files.IndexOf(pageName) >= 0)
                        requireSSL = true;
                }
            }

// check if the Page is currently using the HTTPS scheme
bool isSecureConnection = HttpContext.Current.ApplicationInstance.Request.IsSecureConnection;

// acquire the URI (e.g. http://localhost/default.aspx)
Uri baseUri = HttpContext.Current.ApplicationInstance.Request.Url;

String portToUse = String.Empty;

            if (requireSSL && !isSecureConnection)
            {
                // The page requires SSL and it is currently using the HTTP scheme.
                // Switch the HTTP scheme to the HTTPS scheme
                string url = baseUri.ToString().Replace(baseUri.Scheme, Uri.UriSchemeHttps);

ChangePort(baseUri, true, ref url);

                // perform a 301 redirect to the secure url
                PermanentRedirect(url);
            }
            else if (!requireSSL && isSecureConnection)
            {
                // The page does not require SSL and it is currently using the HTTPS scheme.
                // Switch the HTTPS scheme to the HTTP scheme
                string url = baseUri.ToString().Replace(baseUri.Scheme, Uri.UriSchemeHttp);

ChangePort(baseUri, false, ref url);

                // perform a 301 redirect to the non-secure url
                PermanentRedirect(url);
            }
        }

        /// <summary>
        /// Peforms a 301 redirect to the given url. This is the most search engine friendly
        /// way of redirecting to another Page. The 301 status code means that a Page has
        /// permanently moved to a new location.
        /// </summary>
        /// <param name="url"></param>
        private void PermanentRedirect(string url)
        {
            //throw new Exception("url:" + url);
            HttpContext.Current.Response.Status = "301 Moved Permanently";
            HttpContext.Current.Response.AddHeader("Location", url);
        }

        /// <summary>
        /// Change or remove the port from the url
        /// </summary>
        private void ChangePort(Uri baseUri, Boolean useSecurePort, ref String url)
        {
            String portToUse = String.Empty;

// Get the current port
String portToFind = String.Format(":{0}", baseUri.Port.ToString());

            if (settings != null && settings.SecurityRemovePort)
            {
                // Config setting says to remove the port from the url so lets do that
                url = url.Replace(portToFind, "");
            }
            else
            {
                // Security setting says to leave the port in the url so we need to change it
                if (useSecurePort)
                {
                    // If we are not on the standard port 80 we need to lookup the secure port from iis
                    if (baseUri.Port != 80)
                    {
                        portToUse = LookupSecurePortFromIIS();
                        String portToRepaceWith = String.Format(":{0}", portToUse);
                        url = url.Replace(portToFind, portToRepaceWith);
                    }
                }
                else
                {
                    // If we are not on the standard secure port 443 we need to lookup the non secure port from iis
                    if (baseUri.Port != 443)
                    {
                        portToUse = LookupNonSecurePortFromIIS();
                        String portToRepaceWith = String.Format(":{0}", portToUse);
                        url = url.Replace(portToFind, portToRepaceWith);
                    }
                }
            }
        }

        private String LookupSecurePortFromIIS()
        {
            return LookupPortFromIIS(true);
        }

        private String LookupNonSecurePortFromIIS()
        {
            return LookupPortFromIIS(false);
        }

        /// <summary>
        /// Using DirectoryServices look up in IIS the port that should be used
        /// when swapping from http to https or https to http
        /// </summary>
        private String LookupPortFromIIS(bool findHttpsPort)
        {
            String port = String.Empty;
            System.DirectoryServices.PropertyValueCollection serverBindings;

// Get the current website server instance
String websiteInstanceID = HttpContext.Current.ApplicationInstance.Request["INSTANCE_ID"]; // e.g. 1646904159

            // Connect to the IIS directory service for the website instance id
            System.DirectoryServices.DirectoryEntry path = null;
            if (!String.IsNullOrEmpty(settings.IISServerUsername) && !String.IsNullOrEmpty(settings.IISServerPassword))
                path = new System.DirectoryServices.DirectoryEntry("IIS://localhost/W3SVC/" + websiteInstanceID, settings.IISServerUsername, settings.IISServerPassword);
            else
                path = new System.DirectoryServices.DirectoryEntry("IIS://localhost/W3SVC/" + websiteInstanceID);

            // Find the port number
            if (findHttpsPort) // Get https port
                serverBindings = path.Properties["SecureBindings"];
            else                // Get http port
                serverBindings = path.Properties["serverbindings"];

            if (serverBindings.Value != null)
            {
                String bindingValue = serverBindings.Value.ToString();

// Just get the port number (remove everything else)
bindingValue = bindingValue.Substring(bindingValue.IndexOf(":") + 1);

port = bindingValue.Replace(":", "");
}

            return port;
        }
    }
}

The LookupPortFromIIS method is the one that needs the most explaining. In the case when you are using non standard ports e.g. not 80 for http and not 443 for https, then in order to flip from http://mydomain.com:8054 to https://mydomain.com:4054 this method looks up from the IIS server what port number should be used. So if you were going from http on port 8054 we would look up in IIS that we need port 4054 in order to go secure. And if we were already secure we would look up that we need port 8054 to go non-secure. To do this lookup into IIS we use DirectoryServices which has been tested on IIS6 and IIS7.

And finally to support controlling which pages go secure via the web.config we need to add some configuration code. Add to this project a ‘Configuration’ directory. Under the configuration directory add the following 3 classes (enums.cs, SecureWebPageFileSetting.cs and SecureWebPageSettings.cs).

enums.cs

namespace JL.Web.Security.Configuration
{
    public enum SecureWebPageMode
    {
        /// <summary>
        /// Web page security is on
        /// </summary>
        On,

        /// <summary>
        /// Web page security is off
        /// </summary>
        Off
    }
}

SecureWebPageFileSetting.cs

namespace JL.Web.Security.Configuration
{
    /// <summary>
    /// Represents an file entry in the <secureWebPageSettings>
    /// configuration section.
    /// </summary>
    public class SecureWebPageFileSetting : ConfigurationElement
    {
        #region Constructors
        /// <summary>
        /// Creates an instance of SecureWebPageFileSetting.
        /// </summary>
        public SecureWebPageFileSetting()
            : base()
        {
        }

        /// <summary>
        /// Creates an instance with an initial page name.
        /// </summary>
        /// <param name="pagename">The page class name e.g. login (not login.aspx).</param>
        public SecureWebPageFileSetting(string pagename)
            : this()
        {
            Pagename = pagename;
        }
        #endregion

        /// <summary>
        /// Gets or sets the path of this file setting.
        /// </summary>
        [ConfigurationProperty("pagename", IsRequired = true, IsKey = true)]
        public string Pagename
        {
            get { return (string)this["pagename"]; }
            set { this["pagename"] = value; }
        }
    }

    /// <summary>
    /// Represents a collection of SecureWebPageFileSetting objects.
    /// </summary>
    public class SecureWebPageFileSettingCollection : ConfigurationElementCollection
    {
        /// <summary>
        /// Gets the element name for this collection.
        /// </summary>
        protected override string ElementName
        {
            get { return "files"; }
        }

        /// <summary>
        /// Gets a flag indicating an exception should be thrown if a duplicate element
        /// is added to the collection.
        /// </summary>
        protected override bool ThrowOnDuplicate
        {
            get { return true; }
        }

        /// <summary>
        /// Gets the element at the specified index.
        /// </summary>
        /// <param name="index">The index to retrieve the element from.</param>
        /// <returns>The SecureWebPageFileSetting located at the specified index.</returns>
        public SecureWebPageFileSetting this[int index]
        {
            get { return (SecureWebPageFileSetting)BaseGet(index); }
        }

        /// <summary>
        /// Gets the element with the specified pagename.
        /// </summary>
        /// <param name="pagename">The pagename of the element to retrieve.</param>
        /// <returns>The SecureWebPageFileSetting with the specified pagename.</returns>
        public new SecureWebPageFileSetting this[string pagename]
        {
            get
            {
                if (pagename == null)
                    throw new ArgumentNullException("pagename");
                else
                    return (SecureWebPageFileSetting)BaseGet(pagename.ToLower(CultureInfo.InvariantCulture));
            }
        }

        #region Collection Methods
        /// <summary>
        /// Adds a SecureWebPageFileSetting to the collection.
        /// </summary>
        /// <param name="fileSetting">An initialized SecureWebPageFileSetting instance.</param>
        public void Add(SecureWebPageFileSetting fileSetting)
        {
            BaseAdd(fileSetting);
        }

        /// <summary>
        /// Clears all file entries from the collection.
        /// </summary>
        public void Clear()
        {
            BaseClear();
        }

        /// <summary>
        /// Removes a SecureWebPageFileSetting from the collection with a matching pagename as specified.
        /// </summary>
        /// <param name="pagename">The pagename of a SecureWebPageFileSetting to remove.</param>
        public void Remove(string pagename)
        {
            int Index = IndexOf(pagename);
            if (Index >= 0)
                BaseRemoveAt(Index);
        }

        /// <summary>
        /// Removes the SecureWebPageFileSetting from the collection at the specified index.
        /// </summary>
        /// <param name="index">The index of the SecureWebPageFileSetting to remove.</param>
        public void RemoveAt(int index)
        {
            BaseRemoveAt(index);
        }
        #endregion

        /// <summary>
        /// Creates a new element for this collection.
        /// </summary>
        /// <returns>A new instance of SecureWebPageFileSetting.</returns>
        protected override ConfigurationElement CreateNewElement()
        {
            return new SecureWebPageFileSetting();
        }

        /// <summary>
        /// Gets the key for the specified element.
        /// </summary>
        /// <param name="element">An element to get a key for.</param>
        /// <returns>A string containing the pagename of the SecureWebPageFileSetting.</returns>
        protected override object GetElementKey(ConfigurationElement element)
        {
            if (element != null)
                return ((SecureWebPageFileSetting)element).Pagename.ToLower(CultureInfo.InvariantCulture);
            else
                return null;
        }

        /// <summary>
        /// Returns the index of an item with the specified pagename in the collection.
        /// </summary>
        /// <param name="pagename">The pagename of the item to find.</param>
        /// <returns>Returns the index of the item with the pagename.</returns>
        public int IndexOf(string pagename)
        {
            if (pagename == null)
                throw new ArgumentNullException("pagename");
            else
                return this.IndexOf((SecureWebPageFileSetting)BaseGet(pagename.ToLower(CultureInfo.InvariantCulture)));
        }

        public int IndexOf(SecureWebPageFileSetting item)
        {
            if (item != null)
                return BaseIndexOf(item);
            else
                return -1;
        }
    }
}

SecureWebPageSettings.cs

namespace JL.Web.Security.Configuration
{
    /// <summary>
    /// Contains the settings of a secureWebPageSettings configuration section.
    /// </summary>
    public class SecureWebPageSettings : ConfigurationSection
    {
        /// <summary>
        /// Creates an instance of SecureWebPageSettings.
        /// </summary>
        public SecureWebPageSettings()
            : base()
        {
        }

        #region Properties
        /// <summary>
        /// Gets or sets the mode indicating how the secure web page settings handled.
        /// </summary>
        [ConfigurationProperty("mode", DefaultValue = SecureWebPageMode.On)]
        public SecureWebPageMode Mode
        {
            get { return (SecureWebPageMode)this["mode"]; }
            set { this["mode"] = value; }
        }

        /// <summary>
        /// Gets the collection of file settings read from the configuration section.
        /// </summary>
        [ConfigurationProperty("files")]
        public SecureWebPageFileSettingCollection Files
        {
            get { return (SecureWebPageFileSettingCollection)this["files"]; }
        }

        /// <summary>
        /// Gets or sets the remove port mode. This should be set to true when SSL is on a non standard port
        /// </summary>
        [ConfigurationProperty("securityRemovePort", DefaultValue = false)]
        public bool SecurityRemovePort
        {
            get { return (bool)this["securityRemovePort"]; }
            set { this["securityRemovePort"] = value; }
        }

        /// <summary>
        /// Makes all pages on the site secure, regardless of what is specified in the files section.
        /// </summary>
        [ConfigurationProperty("makeAllPagesSecure", DefaultValue = false)]
        public bool MakeAllPagesSecure
        {
            get { return (bool)this["makeAllPagesSecure"]; }
            set { this["makeAllPagesSecure"] = value; }
        }

        /// <summary>
        /// IIS Server user name use to login to directory services
        /// </summary>
        [ConfigurationProperty("iisServerUsername", DefaultValue = "")]
        public String IISServerUsername
        {
            get { return (String)this["iisServerUsername"]; }
            set { this["iisServerUsername"] = value; }
        }

        /// <summary>
        /// IIS Server password use to login to directory services
        /// </summary>
        [ConfigurationProperty("iisServerPassword", DefaultValue = "")]
        public String IISServerPassword
        {
            get { return (String)this["iisServerPassword"]; }
            set { this["iisServerPassword"] = value; }
        }
        #endregion
    }
}

In our web site we configure the Http to Https flipper:

Add the following line to the web.config configSections.

Add the following line to the web.config modules section under system.webServer.

You can now use the ‘RequireSSLAttribute’' by placing this attribute on any web form code behind page and that page will always go secure e.g.

namespace WebApplication
{
    [RequireSSL]
    public partial class WebForm1 : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
        }
    }
}

And in the web.config add the following to control the http to https flipper settings:

<secureWebPageSettings mode="On" securityRemovePort="False" makeAllPagesSecure="False">
        <files>
            <add pagename="WebForm1" />
        </files>
    </secureWebPageSettings>

secureWebPageSettings mode=”Off” - Disables the http to https flipper, which you will want to do if you are using Visual Studio’s built in web server as that does not support https.

secureWebPageSettings mode =”On” - Enable the flipper, use this when the code is running on an IIS server.

secureWebPageSettings securityRemovePort = “True” - This will remove the port from the URL (to be used in scenario 6 I mentioned at the top of this article).

secureWebPageSettings makeAllPagesSecure = “True” - All pages on your site will go secure.

secureWebPageSettings makeAllPagesSecure = “False” - Only pages using the RequireSSL attribute or those listed in the <files> section in the web.config will go secure. All other pages will flip back to non-secure.

In the add files section you should add a line for each page that you want to go secure. The pagename is the class name of the page (as in the code behind page e.g. WebForm1)

namespace WebApplication
{
    public partial class WebForm1 : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
        }
    }
}

To test the code you will need an SSL, you can create your own on IIS6 using the SelfSSL tool that comes with the IIS6 Resource Kit that can be downloaded here: http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=17275.

Or on IIS7 here is a good post on setting up a self certificate: http://weblogs.asp.net/scottgu/archive/2007/04/06/tip-trick-enabling-ssl-on-iis7-using-self-signed-certificates.aspx

And finally on IIS7 when the app pool is running in Managed Pipeline Mode = Integrated you will need to add the JL.Web.Security.RequireSSLModule to the ‘Modules’ section in IIS Manager for the website.

Here is the source code

Add a Permanent 301 Redirect Route Using .Net Routing 3.5

2011-06-19T08:16:00.001+00:00

As pages on our sites get old and replaced sometimes we need to redirect users to the newer pages. You can do this in .Net Routing by setting up a new route which does a 301 (Permanent) redirect.

You will need a new route handler method to do the redirect. The code for this is shown below:

/// <summary>
/// This route handler allows redirecting old urls to a new page/route name and
/// sets a permanent 301 status code (Moved Permanently)
/// This can be invoked from the global.asax.cs like this:
///     The route below will redirect requests from somedirectory/A.aspx to somedirectory/login
///     routes.Add("OLDRoute1", new CustomRoute("somedirectory/A.aspx", new PermanentRedirectRouteHandler("login")));
/// </summary>
public class PermanentRedirectRouteHandler : IRouteHandler, IHttpHandler
{
    public PermanentRedirectRouteHandler(string virtualPath)
    {
        this.VirtualPath = virtualPath;
    }

public string VirtualPath { get; private set; }
private RequestContext requestContext = null;

    public IHttpHandler GetHttpHandler(RequestContext requestContext)
    {
        this.requestContext = requestContext;
        return this;
    }

    public bool IsReusable
    {
        get { return false; }
    }

    public void ProcessRequest(HttpContext context)
    {
        context.Response.StatusCode = 301;
        context.Response.AppendHeader("Location", VirtualPath);
    }
}

While testing you might want to change the StatusCode to 302 (temporary redirect).

To create a route using the PermanentRedirectRouteHandler method you would add a route like this:

Example 1:

routes.Add("OLDRoute1", new CustomRoute("A.aspx", new PermanentRedirectRouteHandler("login")));

The route above will redirect a request to ‘http://mydomain/A.aspx’ to ‘http://mydomain/login’.

Example 2:

routes.Add("OLDRoute2", new CustomRoute("site1/A.aspx", new PermanentRedirectRouteHandler("login")));

The route above will redirect a request to ‘http://mydomain/site1/A.aspx’ to ‘http://mydomain/site1/login’.

Example 3:

routes.Add("OLDRoute3", new CustomRoute("site1/B.aspx", new PermanentRedirectRouteHandler("/login")));

The route above will redirect a request to ‘http://mydomain/site1/B.aspx’ to ‘http://mydomain/login’.

Example 4:

routes.Add("OLDRoute4", new CustomRoute("contact-us", new PermanentRedirectRouteHandler("/login")));

The route above will redirect a request to ‘http://mydomain/contact-us/’ to ‘http://mydomain/login’.

As routes are evaluated in order you should add the redirect routes to the top of your routes in the Global.asax.

If you missed the first post in this series have a look at Adding .Net Routing 3.5 to Asp.Net Web Forms.

Happy Routing!

Route to Directories That Do Not Exist On The Disc with .Net Routing 3.5

2011-06-19T07:26:00.002+00:00

In my last post we added .Net Routing to web forms, you can find that post here: Adding .Net Routing 3.5 to Asp.Net Web Forms.

This post shows how to create a route that in the url has directories that do not exist on the disc. Typically .Net will through a 404 file cannot be found error if a directory does not exist but .Net Routing allows you to say actually I’m going to accept that route because I know it maps to this location.

e.g. http://mydomain/site1/login/ or http://mydomain/site2/login

In that example site1 & site2 do not exist as directories on the disc, and login is the page we want to show.
What this lets me do is have the same code running under mydomain but have different sites (which may be using different style sheets, etc). The url will always look like it does above for each site, so users can easily bookmark it.

This lets both sites use the same pages, without deploying the same code again or creating multiple virtual directories.

How will the routes look in the Global.asax? Like this:

public static void RegisterRoutes(RouteCollection routes)
{
    // The routes:
    routes.Add("Site1Default", new CustomRoute("Site1", new URLRouteHandler("~/Login.aspx")));
    routes.Add("Site2Default", new CustomRoute("Site2", new URLRouteHandler("~/Login.aspx")));

    routes.Add(“Site1” + PageIdentifier.Login.ToString(), new CustomRoute("site1/login", new URLRouteHandler("~/Login.aspx")));

    routes.Add(“Site2” + PageIdentifier.Login.ToString(), new CustomRoute("site2/login", new URLRouteHandler ("~/Login.aspx")));

    routes.Add(“Site1” + PageIdentifier.Logout.ToString(), new CustomRoute("site1/logout", new URLRouteHandler("~/Logout.aspx")));

    routes.Add(“Site2” + PageIdentifier.Logout.ToString(), new CustomRoute("site2/logout", new URLRouteHandler("~/Logout.aspx")));
}

The first 2 routes ‘Site1Default’ & ‘Site2Default’ say if a url like http://mydomain/site1/’ is entered then by default go to the login.aspx page.

How can I get Normal .aspx pages to work under the missing directories?

So far by doing the above will mean that normal aspx pages will not work with the missing site1 & site2 directorues e.g. http://mydomain/site1/Login.aspx’. This will throw a 404 file not found exception. But if you want them to work you can add a couple of extra routes at the end of your existing routes like this.

routes.Add("Site1ASPX", new CustomRoute("site1/{page}", new DefaultURLRouteHandler()));

routes.Add("Site2ASPX", new CustomRoute("site2/{page}", new DefaultURLRouteHandler()));

This says everything under site1/* should be handled by the DefaultURLRouteHandler, and this route handler is expecting the {page} parameter e.g. ‘http://mydomain/site1/Login.aspx’ in this example the {page} parameter is ‘Login.aspx’.

The code for the DefaultURLRouteHandler is shown below:

/// <summary>
/// This route handler allows standard .aspx pages to work where there are directories that do not exist on disk
/// e.g. somedirectory/login.aspx will reroute to login.aspx even though on disk somedirectory does not exist
/// This can be invoked from the global.asax.cs like this:
///     var route = new CustomRoute("somedirectory/{page}", new DefaultURLRouteHandler());
/// </summary>
public class DefaultURLRouteHandler : IRouteHandler
{
    public DefaultURLRouteHandler()
    {
    }

    public System.Web.IHttpHandler GetHttpHandler(RequestContext requestContext)
    {
        string filename = requestContext.RouteData.Values["page"] as string;

foreach (var paramUrl in requestContext.RouteData.Values)
requestContext.HttpContext.Items[paramUrl.Key] = paramUrl.Value;

        try
        {
           var page = BuildManager.CreateInstanceFromVirtualPath("~/" + filename, typeof(Page)) as IHttpHandler;
            return page;
        }
        catch (Exception)
        {
            throw;
        }
    }
}

The line in red is where the magic happens.

Happy routing!

Adding .Net Routing 3.5 to Asp.Net Web Forms

2011-06-18T10:53:00.002+00:00

This article shows how to take a web forms application and enable it to use .Net Routing 3.5.

Why should I do this you might ask, well as you know web forms renders urls like: http://mydomain/Login.aspx. Which is not very friendly to a user especially when you start adding parameters.

Would it not be better to have the url like this: http://mydomain/login/. That’s nicer for the user to read and search engines will appreciate it more!

You can even do things like:
http://mydomain/log-user-in/
http://mydomain/product/1/ (which without routing would be http://mydomain/Product.aspx?id=1)

To enable .Net Routing in your web project you need to do the following:
1. Add these 2 references to your web project:
System.Web.Routing and System.Web.Abstractions
Whilst System.Web.Abstractions is not needed for .Net Routing we will use it later in this post.

2. Add the following to your web.config inside the <httpModules> section

<add name="RoutingModule" type="System.Web.Routing.UrlRoutingModule, System.Web.Routing, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>

e.g.

3. Now we need to setup the routing which is done in the Global.asax.cs file (if you do not have one you can add it by ‘Right Click –> Add New Item’.

Add the following RegisterRoutes method to the Application_Start.

protected void Application_Start(object sender, EventArgs e)
{
// .Net Routing Start up
RegisterRoutes(RouteTable.Routes);
}

Now create the RegisterRoutes method and add your routes to it like this:

public static void RegisterRoutes(RouteCollection routes)
{
    // The routes:
    routes.Add("Default", new CustomRoute("", new URLRouteHandler("~/Login.aspx")));

    routes.Add(PageIdentifier.Login.ToString(), new CustomRoute("login", new URLRouteHandler("~/Login.aspx")));

    routes.Add(PageIdentifier.Logout.ToString(), new CustomRoute("logout", new URLRouteHandler("~/Logout.aspx")));

    routes.Add(PageIdentifier.ContactUs.ToString(), new CustomRoute("contact-us", new URLRouteHandler("~/ContactUs.aspx")));
}

To explain, the syntax of a route is essentially routes.Add(nameOfTheRoute, route);

nameOfTheRoute - is simply a string, but this is an important parameter as later on you can create a method to to find the route by using this string. Which is why I like to use the PageIdentifier enum e.g.

public enum PageIdentifier : int
{
    Login = 1,
    Logout = 2,
    ContactUs = 21,
}

route – this at it’s simplest contains the name of the route (which is shown in the url), and where to route to e.g. the .aspx page.

Most of your routes will look something like the one below which means that ‘login’ is shown in the url (e.g. ‘http://mydomain/login’) when the login.aspx page is shown.

routes.Add(PageIdentifier.Login.ToString(), new CustomRoute("login", new URLRouteHandler("~/Login.aspx")));

But you can also setup a default route so if now route is specified in the url (e.g. ‘http://mydomain/’) then go to the login.aspx page.

routes.Add("Default", new CustomRoute("", new URLRouteHandler("~/Login.aspx")));

4. You may have noticed that we have missed something, what’s this CustomRoute and URLRouteHandler.

4.1. URLRouteHandler
In order to route our request to an .aspx page you need to create a route handler that will do this. When you use the URLRouteHandler e.g.

new URLRouteHandler("~/Login.aspx")

the Login.aspx is the page you want displayed, the URLRouteHandler essentially creates an instance of this page and returns it.

/// <summary>
/// Maps a .Net Route to an .aspx page
/// This can be invoked from the global.asax.cs like this:
/// routes.Add("ContactUs", new CustomRoute("contact-us", new URLRouteHandler("~/ContactUs.aspx")));
/// </summary>
public class URLRouteHandler : IRouteHandler
{
    public URLRouteHandler(string virtualPath)
    {
        this.VirtualPath = virtualPath;
    }

    public string VirtualPath { get; private set; }

    public System.Web.IHttpHandler GetHttpHandler(RequestContext requestContext)
    {
        foreach (var paramUrl in requestContext.RouteData.Values)
            requestContext.HttpContext.Items[paramUrl.Key] = paramUrl.Value;
        try
        {
            var page = BuildManager.CreateInstanceFromVirtualPath(VirtualPath, typeof(Page)) as IHttpHandler;
            return page;
        }
        catch (Exception)
        {
            throw;
        }
    }
}

4.2. CustomRoute
While you can just use the ‘Route’ class provided by .Net Routing, I found it useful to create a new CustomRoute class. This class below will always render a url returned to the browser in lowercase and will append a trailing slash e.g. ‘http://mydomain/login/’. This is useful for improving your Google search engine ranking.

/// <summary>
/// Override of the .Net Routing 'Route' class, to ensure the url returned is always lowercase and has a trailing slash.
/// </summary>
public class CustomRoute : Route
{
    #region Constructors
    public CustomRoute(string url, IRouteHandler routeHandler)
        : base(url, routeHandler)
    {
    }

    public CustomRoute(string url, RouteValueDictionary defaults, IRouteHandler routeHandler)
        : base(url, defaults, routeHandler)
    {
    }

    public CustomRoute(string url, RouteValueDictionary defaults, RouteValueDictionary constraints, IRouteHandler routeHandler)
        : base(url, defaults, constraints, routeHandler)
    {
    }

    public CustomRoute(string url, RouteValueDictionary defaults, RouteValueDictionary constraints, RouteValueDictionary dataTokens, IRouteHandler routeHandler)
        : base(url, defaults, constraints, dataTokens, routeHandler)
    {
    }
    #endregion

    public override RouteData GetRouteData(System.Web.HttpContextBase httpContext)
    {
        var routeDate = base.GetRouteData(httpContext);
        return routeDate;
    }

    public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
    {
        VirtualPathData path = base.GetVirtualPath(requestContext, values);
        // Make sure the path returned is lowercase and has a trailing slash (SEO friendly)
        if (path != null)
            path.VirtualPath = path.VirtualPath.ToLowerInvariant() + "/";
        return path;
    }
}

5. Up to now the routing will work if you type the route into the url, but we also need to be able to show the routes on our website as links e.g. <a href=”somelinkhere”>click me</a>

Suppose you had this on a page:

<asp:HyperLink ID="LogoutHyperLink" runat="server">Log Out</asp:HyperLink>

and instead of the NavigateUrl being ‘Logout.aspx’ which in the browser would show up as ‘http://mydomain/Logout.aspx’ you wanted to show the route e.g. ‘http://mydomain/logout/’.

You can do this simply by using that PageIdentifer enum I mentioned at the start of this post.

LogoutHyperLink.NavigateUrl = LinkFactory.GetRoute(PageIdentifier.Logout.ToString());

And the code for the LinkFactory class is shown below (creating this class just makes it easier to reuse later as you would want to do this for every hyperlink on your site).

public class LinkFactory
{
   /// <summary>
   /// Determines the url path (route) to return based on the routeName passed in.
   /// A routeName must exist in the global.asax.cs
   /// </summary>
   /// <param name="context"></param>
   /// <param name="routeName"></param>
   /// <returns></returns>
   public static string GetRoute(String routeName)
   {
       var pathData = System.Web.Routing.RouteTable.Routes.GetVirtualPath(
             null, routeName, new System.Web.Routing.RouteValueDictionary { });
       return pathData.VirtualPath;
   }
}

One final point, is all your existing .aspx pages will continue to work as they do today because .Net routing only kicks in when a page cannot be found on disc.

Here is the source code

That’s it, happy routing!

MVC3 RadioButtonList Helper

2011-06-12T09:06:00.001+00:00

An MVC 3 example which uses the Radio Button helper twice on a page to create 3 radio buttons with the first radio button helper and 2 radio buttons with the 2nd helper. Both have validation to ensure 1 option is selected. And if the form fails validation the chosen radio option is preselected when the form is reshown.

The radio buttons can be shown on the page horizontally or vertically.

The Html Helper Method

Essentially all this helper does is loop round a list that you provide it and for each item in the list creates a html radio button and a label for it.

I created a new class with the following code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Mvc.Html;
using System.Linq.Expressions;
using System.Text;

namespace MVC3_RadioButtonList_Helper_Sample
{
    public static class HtmlExtensions
    {
        public static MvcHtmlString RadioButtonForSelectList<TModel, TProperty>(
            this HtmlHelper<TModel> htmlHelper,
            Expression<Func<TModel, TProperty>> expression,
            IEnumerable<SelectListItem> listOfValues)
        {
            var metaData = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
            var sb = new StringBuilder();

            if (listOfValues != null)
            {
                // Create a radio button for each item in the list
                foreach (SelectListItem item in listOfValues)
                {
                    // Generate an id to be given to the radio button field
                    var id = string.Format("{0}_{1}", metaData.PropertyName, item.Value);

                    // Create and populate a radio button using the existing html helpers
                    var label = htmlHelper.Label(id, HttpUtility.HtmlEncode(item.Text));
                    var radio = htmlHelper.RadioButtonFor(expression, item.Value, new { id = id }).ToHtmlString();

                    // Create the html string that will be returned to the client
                    // e.g. <input data-val="true" data-val-required="You must select an option" id="TestRadio_1" name="TestRadio" type="radio" value="1" /><label for="TestRadio_1">Line1</label>
                    sb.AppendFormat("<div class=\"RadioButton\">{0}{1}</div>", radio, label);
                }
            }

            return MvcHtmlString.Create(sb.ToString());
        }
    }
}

I’ve added a div around the radio button and it’s label with a class of ‘RadioButton’, this will let you in CSS position the radio button either vertically or horizontally. The default is vertically:

But you can switch this to horizontal with a bit of CSS

.RadioButton { float:left; }

The rest of this article shows how to use the RadioButtonForSelectList helper, you reference it in a view like this: @Html.RadioButtonForSelectList(m => m.TestRadio, Model.TestRadioList)

The Model

For this example I just created an empty MVC3 application and added this model.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.ComponentModel.DataAnnotations;
using System.Web.Mvc;

namespace MVC3_RadioButtonList_Helper_Sample.Models
{
    public class IndexViewModel
    {
        public IEnumerable<SelectListItem> TestRadioList { get; set; }
        public IEnumerable<SelectListItem> TestRadioList2 { get; set; }

[Required(ErrorMessage = "You must select an option for TestRadio")]
public String TestRadio { get; set; }

        [Required(ErrorMessage = "You must select an option for TestRadio2")]
        public String TestRadio2 { get; set; }
    }

    public class aTest
    {
        public Int32 ID { get; set; }
        public String Name { get; set; }
    }
}

The Controller Action

I added the following to my controller to populate the model with 2 different lists one for each of the radio button helpers. The first radio button help also has a default value set so the middle option (‘Line2’) will be pre-selected.

I also changed the Index HttpPost method so that if validation fails the same list of radio buttons is added to the model (obviously I have duplicated the list creation code, in a live example you should create a common function).

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using MVC3_RadioButtonList_Helper_Sample.Models;

namespace MVC3_RadioButtonList_Helper_Sample.Controllers
{
    public class TestController : Controller
    {
        //
        // GET: /Test/
        public ActionResult Index()
        {
            List<aTest> list = new List<aTest>();
            list.Add(new aTest() { ID = 1, Name = "Line1" });
            list.Add(new aTest() { ID = 2, Name = "Line2" });
            list.Add(new aTest() { ID = 3, Name = "Line3" });
            SelectList sl = new SelectList(list, "ID", "Name");

            List<aTest> list2 = new List<aTest>();
            list2.Add(new aTest() { ID = 1, Name = "test1" });
            list2.Add(new aTest() { ID = 2, Name = "test2" });
            SelectList sl2 = new SelectList(list2, "ID", "Name");

            var model = new IndexViewModel();
            model.TestRadioList = sl;
            model.TestRadioList2 = sl2;

            model.TestRadio = "2"; // Set a default value for the first radio button helper

return View(model);
}

        [HttpPost]
        public ActionResult Index(IndexViewModel model, string returnUrl)
        {
            if (ModelState.IsValid)
            {
                ModelState.AddModelError("", "Always force an error to be raised so we can test the postback sets the radio buttons to their last values.");
            }

            // If we got this far, something failed, redisplay form
            List<aTest> list = new List<aTest>();
            list.Add(new aTest() { ID = 1, Name = "Line1" });
            list.Add(new aTest() { ID = 2, Name = "Line2" });
            list.Add(new aTest() { ID = 3, Name = "Line3" });
            SelectList sl = new SelectList(list, "ID", "Name");

model.TestRadioList = sl;
model.TestRadioList2 = sl2;

            return View(model);
        }
    }
}

The View

To test the html helper I added a view that is bound to the IndexViewModel.

I added a using statement so the helper method would be found by intelisence @using MVC3_RadioButtonList_Helper_Sample

I added the new helper RadioButtonForSelectList and passed in the TestRadio property from the IndexViewModel which is where the selected result will be put (the radio button ID value e.g. 2).

And the TestRadioList which is a list of SelectListItems for which a radio button will be created for each item in the list.

@Html.RadioButtonForSelectList(m => m.TestRadio, Model.TestRadioList)
@Html.ValidationMessageFor(m => m.TestRadio)

So the error message (as specified in the model ‘TestRadio’ property is shown when no radio button is selected I added a validation message helper.

I then added a 2nd radio button helper to the form like this, which is bound to a different list and it’s return value will be in TestRadio2.

@Html.RadioButtonForSelectList(m => m.TestRadio2, Model.TestRadioList2)
@Html.ValidationMessageFor(m => m.TestRadio2)

The form below shows the validation in action:

Here is the source code.

How to Add Parameters and Callback Functions to Your JQuery Plugins

2010-01-13T18:28:00.001+00:00

Today I am going to expand on the AlertMe plugin I created in the last article. I will show you how to pass parameters into the plugin, and show you how to create a callback handler for your JQuery plugin.

1. Parameters can be entered one after the other as part of the function method call e.g. jQuery.fn.AlertMe = function(param1, param2, etc).

But then you have to specify all those parameters when calling the function which is a problem when some of the parameters are optional!.

Instead what I prefer is creating a function in the plugin which will contain all the parameters. It also allows setting each parameter to a default value which can later be changed/overridden by the calling client code.

Below is the plugin function, note it has the same name as the main plugin code but has .defaults appended to it.

jQuery.fn.AlertMe.defaults = {
alertText: 'AlertMe default text',
onAlert: function(alertText) { }
};

The alertText line has a default set of ‘AlertMe default text’ which will be displayed in the alert box.

And onAlert is a function that allows the client to specify a function that will run when the alert box is shown.

2. Below is the full code for the AlertMe plugin. As before I placed this code in a file called ‘jquery.AlertMe.js’.

And below is the client html code.

                $("div").AlertMe(myoptions);
            });
        </script>
    </head>

The main part of the above code is the part shown below:

var myoptions = {
    alertText: 'AlertMe changed by client',

    onAlert: function(alertText) {
        alert(alertText);
    }
}

This is where we can change the default parameter values and setup our functions to handle the callback’s provided in the plugin.

3. When you run this code in a web browser a couple of alert boxes will be shown.

The first alert box will say: ‘AlertMe changed by client’. This is because I set the alertText option. If I had not set the alertText option the default message of ‘AlertMe default text’ would have been shown.

The second alert box will say:
‘AlertMe changed by client and then changed by doAlert function callback’.

The second alert box says this because the client has subscribed to the onAlert callback function and inside the plugin when the alert is shown the text returned by the onAlert function is changed which for this demo helps us see that the callback is working.

Create Your First JQuery Plugin

2010-01-06T18:34:00.001+00:00

This article will show you how to create a simple JQuery plugin.

1. To create a jQuery plugin you should:

Name the script file as jquery.YourPluginName.js e.g. jquery.AlertMe.js.
Your function must end with a semi-colon.
You should use this.each as it produces compatible code.
You should not use $ within the plugin unless it is aliased, you should use jQuery instead.
Variables should be initialised using the var keyword.

2. Below is a very simple jQuery plugin.

(function($) {
    jQuery.fn.AlertMe = function() {
        return this.each(function() {
            alert(“AlertMe”);
        });
    };
})(jQuery);

3. Using a function within a JQuery plugin. Below i’ve added a doAlert() function.

4. Using variables within a JQuery plugin. Variables should be initialised using the var keyword.

5. Your JQuery plugin can then be called from a web page like this:

Reference the JQuery library and your plugin script files in the <head> section of your page like so:

And on your web page you can use the plugin like this:

$("div").AlertMe();

A bigger example of using the plugin from a web page:

<html>
    <head>
        <script src="jquery-1.3.2.js" type="text/javascript"></script>
        <script src="jquery.AlertMe.js" type="text/javascript"></script>

        <script type="text/javascript">
            $(document).ready(function() {
                $("div").AlertMe();
            });
        </script>
    </head>

       <body>
        <h1>Alert Me JQuery Web Page Example</h1>
        <div></div>
    </body>
</html>

This will attach the ‘AlertMe’ plugin to every div element on the page. So for example if you had 2 divs you would see 2 alert boxes displayed.

Convert Exceptions in WCF Services to Fault Exceptions a Client Can Use

2009-12-22T17:57:00.003+00:00

This article will show you how to trap an exception that occurs within a WCF service but also inform the client application of the exception so it can be handled. To do this we will make use of a custom faultException.

1. You need to create a fault contract for the type of fault that you want to be returned to the client via WCF. Below I have created a ‘DBConcurrencyFault’ fault that tells the client when a database concurrency violation has occurred (e.g. 2 people tried to save the same record).

namespace Common.Services.Faults
{
    [DataContract]
    public class DBConcurrencyFault
    {
        [DataMember]
        public String Message { get; set; }

        [DataMember]
        public String ExceptionType { get; set; }
    }
}

2. Now we are going to create a new attribute that we can use to decorate our service classes with. This attribute will trap any exception occurring in a WCF service and convert them into a specific fault exception.

namespace Common.Services
{
    public class WcfErrorHandler : Attribute, IErrorHandler, IServiceBehavior
    {
        public bool HandleError(Exception error)
        {
            return false;
        }

        public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault)
        {
            if (fault != null)
                return;

            if (error.GetType() == typeof(System.Data.DBConcurrencyException))
            {
                // Handle Database record being written to by different users (Conncurrency Fault)
                DBConcurrencyFault databaseConcurrencyFault = new DBConcurrencyFault();
                databaseConcurrencyFault.Message = error.Message;
                databaseConcurrencyFault.ExceptionType = error.GetType().ToString();
                String faultReason = "Someone else has already saved this record.";
                FaultException<DBConcurrencyFault> faultException = new FaultException<DBConcurrencyFault>(databaseConcurrencyFault, faultReason);
                MessageFault messageFault = faultException.CreateMessageFault();
                fault = Message.CreateMessage(version, messageFault, faultException.Action);
            }
            else
            {
                // Handle all other errors as standard FaultExceptions
                FaultException faultException = new FaultException(error.Message);
                MessageFault messageFault = faultException.CreateMessageFault();
                fault = Message.CreateMessage(version, messageFault, faultException.Action);
            }
        }

        #region IServiceBehavior Members
        public void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, System.Collections.ObjectModel.Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters)
        {
        }

        public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
        {
            foreach (ChannelDispatcher disp in serviceHostBase.ChannelDispatchers)
            {
                disp.ErrorHandlers.Add(this);
            }
        }

        public void Validate(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
        {
        }
        #endregion
    }
}

Note: the ‘ProvideFault’ method contains code that determines if an exception of type ‘System.Data.DBConcurrencyException’ has occurred. If one has it is converted into a ‘DBConcurrencyFault’ which is then returned to the calling client by the WCF service.

3. Now you can either add the WcfErrorHandler attribute to all your wcf services, or you can as I have below define a base service class that all your service classes will inherit from.

namespace Common.Services
{
   [WcfErrorHandler()]
   public class BaseService
   {
       // Common service methods go here
   }
}

4. Have your service class inherit from the base service class.

public class MileageClaimService : BaseService, IMileageClaimService
{
// Service methods go here
}

5. Trap the fault exception from a web client and redirect the user to a tailored error page.
5a. For an Asp.Net web application you can add the exception handling code to the global.asax Application_Error method.

protected void Application_Error(object sender, EventArgs e)
{
     Exception ex = Server.GetLastError().GetBaseException();

     if (ex.GetType() == typeof(System.ServiceModel.FaultException<Common.Services.Faults.DBConcurrencyFault>) )
     {
        Server.ClearError();
        Response.Redirect("~/Errors/ErrorDbConcurrency.aspx");
     }
}

5b. From an Asp.Net MVC web application you just add a HandleError attribute to the controller with the type of DBConcurrencyFault and redirect to a specific view.

[HandleError(ExceptionType = typeof(System.ServiceModel.FaultException<Common.Services.Faults.DBConcurrencyFault>),
View = "ErrorDbConcurrency")]
[HandleError]
public class ClaimController : Controller
{
// Controller methods go here
}

Note: There are 2 HandleError attributes, the first handles the DBConcurrencyFault and redirects to a custom error page. The 2nd traps all other exceptions and redirects to the default error page. The order of these 2 HandleError attributes is important.

Constructor Dependency Injection with a WCF Service using Unity

2009-12-18T17:55:00.002+00:00

In a previous article I showed how to use dependency injection to specify in a config file which repository should be used by a non WCF service.

This article will show how to do the same but for a WCF service.

The previous article can be found here.

1. WCF uses interfaces so the first thing we need to do is add an interface to our service to WCF enable it. Since the service is called MileageClaimService I will call the interface IMileageClaimService. Below is the interface definition decorated with WCF ServiceContract and OperationContract attributes.

namespace Service.Finance.Mileage.Interfaces
{
    [ServiceContract(
        Name = "MileageClaimService",
        Namespace = "http://mycompany.com/services/finance/v1.0.0.0")]
    public interface IMileageClaimService
    {
        [OperationContract(Name = "GetAllClaimsForEmployee")]
        List<DTO.Finance.Mileage.MileageClaim> GetAllClaimsForEmployee(string employeePayrollNumber);

        [OperationContract(Name = "GetClaimById")]
        DTO.Finance.Mileage.MileageClaim GetClaimById(int id);

        [OperationContract(Name = "GetClaimByReferenceNumber")]
        DTO.Finance.Mileage.MileageClaim GetClaimByReferenceNumber(string referenceNumber);

        [OperationContract(Name = "Save")]
        [FaultContract(typeof(DBConcurrencyFault))]
        void Save(ref DTO.Finance.Mileage.MileageClaim claim);

        [OperationContract(Name = "Delete")]
        void Delete(DTO.Finance.Mileage.MileageClaim claim);

        [OperationContract(Name = "SubmitClaim")]
        void SubmitClaim(DTO.Finance.Mileage.MileageClaim claim);
    }
}

Below I’ve added the interface and the ServiceBehavior attribute to the service.

namespace Service.Finance.Mileage
{
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
    public class MileageClaimService : IMileageClaimService
    {
        IMileageClaimRepository _mileageClaimRepository;
       [InjectionConstructor]
        public MileageClaimService(IMileageClaimRepository mileageClaimRepository)
        {
        }

        // Other service methods go here
    }
}

2. We need to create the Unity classes for WCF.
I’ve created a project called Common. In here I’m going to place the Unity WCF classes (there are 3 of them) in a directory called Services\Unity. You can just copy the code to your own project as I did (thanks to dperez for helping me with this: http://blogs.southworks.net/dperez/2008/11/02/unity-friends-the-wcf-service-host-side/).

InjectionBehavior.cs

using System.Collections.ObjectModel;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.ServiceModel.Dispatcher;
using Microsoft.Practices.Unity;

// WCF Unity Injection Behavior
namespace Common.Services.Unity
{
    /// <summary>
    /// Creates services instance by using Unity type resolution.
    /// </summary>
    public class InjectionBehavior : IServiceBehavior
    {
        /// <summary>
        /// Injection container.
        /// </summary>
        private IUnityContainer container;

        /// <summary>
        /// Initializes a new instance of the InjectionBehavior class.
        /// </summary>
        /// <param name="container">Injection container.</param>
        public InjectionBehavior(IUnityContainer container)
        {
            this.container = container;
        }

        /// <summary>
        /// Provides the ability to pass custom data to binding elements to support the contract implementation.
        /// </summary>
        /// <param name="serviceDescription">The service description of the service.</param>
        /// <param name="serviceHostBase">The host of the service.</param>
        /// <param name="endpoints">The service endpoints.</param>
        /// <param name="bindingParameters">Custom objects to which binding elements have access.</param>
        public void AddBindingParameters(
            ServiceDescription serviceDescription,
            ServiceHostBase serviceHostBase,
            Collection<ServiceEndpoint> endpoints,
            BindingParameterCollection bindingParameters)
        {
        }

        /// <summary>
        /// Provides the ability to change run-time property values or insert custom extension objects such as error handlers, message or parameter interceptors, security extensions, and other custom extension objects.
        /// </summary>
        /// <param name="serviceDescription">The service description.</param>
        /// <param name="serviceHostBase"> The host that is currently being built.</param>
        public void ApplyDispatchBehavior(ServiceDescription serviceDescription, System.ServiceModel.ServiceHostBase serviceHostBase)
        {
            foreach (var channelDispatcherBase in serviceHostBase.ChannelDispatchers)
            {
                var channelDispatcher = channelDispatcherBase as ChannelDispatcher;
                if (channelDispatcher != null)
                {
                    foreach (var endpointDispatcher in channelDispatcher.Endpoints)
                    {
                        endpointDispatcher.DispatchRuntime.InstanceProvider = new InjectionInstanceProvider(this.container, serviceDescription.ServiceType);
                    }
                }
            }
        }

        /// <summary>
        /// Provides the ability to inspect the service host and the service description to confirm that the service can run successfully.
        /// </summary>
        /// <param name="serviceDescription">The service description.</param>
        /// <param name="serviceHostBase">The service host that is currently being constructed.</param>
        public void Validate(ServiceDescription serviceDescription, System.ServiceModel.ServiceHostBase serviceHostBase)
        {
        }
    }
}

InjectionElement.cs

using System;
using System.Configuration;
using System.ServiceModel.Configuration;
using Microsoft.Practices.Unity;
using Microsoft.Practices.Unity.Configuration;

// WCF Unity Injection Element
namespace Common.Services.Unity
{
    /// <summary>
    /// Injection element class representing a behavior extension configuration tag.
    /// </summary>
    public class InjectionElement : BehaviorExtensionElement
    {
        /// <summary>
        /// Default Unity configuration section path.
        /// </summary>
        private const string DefaultUnityConfigurationSectionPath = "unity";

        /// <summary>
        /// Initializes a new instance of the InjectionElement class.
        /// </summary>
        public InjectionElement()
        {
            this.UnityConfigurationSectionPath = DefaultUnityConfigurationSectionPath;
        }

        /// <summary>
        /// Gets the type of behavior.
        /// </summary>
        /// <value>Behavior type.</value>
        public override Type BehaviorType
        {
            get
            {
                return typeof(InjectionBehavior);
            }
        }

        /// <summary>
        /// Gets or sets the injection container name.
        /// </summary>
        /// <value>Container name.</value>
        [ConfigurationProperty("containerName")]
        public string ContainerName
        {
            get;
            set;
        }

        /// <summary>
        /// Gets or sets the Unity configuration section path to read configuration from.
        /// </summary>
        /// <value>Configuration path.</value>
        [ConfigurationProperty("unityConfigurationSectionPath", DefaultValue = DefaultUnityConfigurationSectionPath)]
        public string UnityConfigurationSectionPath
        {
            get;
            set;
        }

        /// <summary>
        /// Creates a behavior extension based on the current configuration settings.
        /// </summary>
        /// <returns>The behavior extension.</returns>
        protected override object CreateBehavior()
        {
            var unitySection = ConfigurationManager.GetSection(this.UnityConfigurationSectionPath) as UnityConfigurationSection;
            IUnityContainer container = new UnityContainer();
            if (this.ContainerName == null)
            {
                unitySection.Containers.Default.Configure(container);
            }
            else
            {
                unitySection.Containers[this.ContainerName].Configure(container);
            }
            return new InjectionBehavior(container);
        }
    }
}

InjectionInstanceProvider.cs

using System;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Dispatcher;
using Microsoft.Practices.Unity;

// WCF Unity Injection Provider
namespace Common.Services.Unity
{
    /// <summary>
    /// Injection instance provider for new service instances.
    /// </summary>
    internal sealed class InjectionInstanceProvider : IInstanceProvider
    {
        /// <summary>
        /// Injection container.
        /// </summary>
        private IUnityContainer container;

        /// <summary>
        /// Type of the service implementation.
        /// </summary>
        private Type instanceType;

        /// <summary>
        /// Initializes a new instance of the InjectionInstanceProvider class.
        /// </summary>
        /// <param name="container">Injection container.</param>
        /// <param name="instanceType">Type of the service implementation.</param>
        public InjectionInstanceProvider(IUnityContainer container, Type instanceType)
        {
            this.container = container;
            this.instanceType = instanceType;
        }

        /// <summary>
        /// Returns a service object given the specified System.ServiceModel.InstanceContext object.
        /// </summary>
        /// <param name="instanceContext">The current System.ServiceModel.InstanceContext object.</param>
        /// <param name="message">The message that triggered the creation of a service object.</param>
        /// <returns>The service object.</returns>
        public object GetInstance(InstanceContext instanceContext, Message message)
        {
            return this.container.Resolve(this.instanceType);
        }

        /// <summary>
        /// Returns a service object given the specified System.ServiceModel.InstanceContext object.
        /// </summary>
        /// <param name="instanceContext">The current System.ServiceModel.InstanceContext object.</param>
        /// <returns>The service object.</returns>
        public object GetInstance(InstanceContext instanceContext)
        {
            return this.GetInstance(instanceContext, null);
        }

        /// <summary>
        /// Called when an System.ServiceModel.InstanceContext object recycles a service object.
        /// </summary>
        /// <param name="instanceContext">The service's instance context.</param>
        /// <param name="instance">The service object to be recycled.</param>
        public void ReleaseInstance(InstanceContext instanceContext, object instance)
        {
            this.container.Teardown(instance);
        }
    }
}

3. Now we need to update the app.config file for the service project. Below shows the configuration to enable the service for Unity dependency injection (it’s exactly the same as in the previous post).

And below is the new configuration to enable the service for WCF using the Unity behavior.

<system.serviceModel>
    <extensions>
      <behaviorExtensions>
        <add name="unity" type="Common.Services.Unity.InjectionElement, Common, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/>
      </behaviorExtensions>
    </extensions>
    <bindings>
      <netTcpContextBinding>
        <binding name="netTcpContextBindingConfig" transactionFlow="true" />
      </netTcpContextBinding>
    </bindings>

    <services>
      <service behaviorConfiguration="Service.ServiceBehavior" name="Service.Finance.Mileage.MileageClaimService">
        <endpoint address="" binding="netTcpContextBinding" bindingConfiguration="netTcpContextBindingConfig"
          name="TcpBinding_MileageClaimService" contract="Service.Finance.Mileage.Interfaces.IMileageClaimService" />
        <endpoint address="mex" binding="mexTcpBinding" name="MexTcpBinding_MileageClaimService"
          contract="IMetadataExchange" />
        <host>
          <baseAddresses>
            <add baseAddress="net.tcp://localhost:8734/Services.Finance/MileageClaimService/v1.0.0.0" />
          </baseAddresses>
        </host>
      </service>
    </services>

     <behaviors>
      <serviceBehaviors>
        <behavior name="Service.ServiceBehavior">
          <serviceMetadata httpGetEnabled="false"/>
          <serviceDebug includeExceptionDetailInFaults="false" />
          <unity />
        </behavior>
      </serviceBehaviors>
    </behaviors>
</system.serviceModel>

Note the behaviorExtensions section contains a Unity entry. This points to the Unity InjectionElement class you added in the last section.

Also note the <unity /> line in the serviceBehaviors.

Both of these are critical to enabling the WCF service to use Unity dependency injection.

Thats it, you can use the wcf service as you would do any wcf service by adding a service reference to your client project and calling the methods on it. The repository will be injected automatically into the constructor on the service because of the behavior extensions defined in the wcf configuration.

Constructor Dependency Injection using Unity (Enterprise Library)

2009-12-17T17:42:00.002+00:00

In the previous article I discussed using the repository design pattern. I also showed how to use a service layer which can then call the repository data access layer. This was done by specifying in code which repository to use in the constructor of the service.

This article will show how to use dependency injection to specify in the web.config / app.config which repository should be used by the service.

The previous article can be found here and you should understand this before continuing.

1. You need to download Enterprise Library 4.1 or higher which contains the dependency injection block called ‘Unity’.

2. You need to add references for Microsoft.Practices.Unity.Configuration.dll and Microsoft.Practices.Unity.dll to the service project.

3. The only change you need to make to the service is to specify which constructor is the one that should be enabled for dependency injection. You do this by using the [InjectionConstructor] attribute.

namespace Service.Finance.Mileage
{
    public class MileageClaimService
    {
        IMileageClaimRepository _mileageClaimRepository;

         [InjectionConstructor]
        public MileageClaimService(IMileageClaimRepository mileageClaimRepository)
        {
        }

        // Other service methods go here
    }
}

4. For ease of use, its useful to create a helper class to hide the Unity code that is needed to work out the repository to use for the service. I’ve called the class ‘UnityDependencyInjectionHelper’ and its best to place it in a common project as it will be reused so I have a project called Common.Service. You can just copy the following code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Practices.Unity;
using Microsoft.Practices.Unity.Configuration;
using System.Configuration;

namespace Service.Common
{
    public static class UnityDependencyInjectionHelper
    {
        private static IUnityContainer container;

        private static void Init()
        {
            container = new UnityContainer();
            UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
            section.Containers.Default.Configure(container);
        }

        public static T Resolve<T>()
        {
            Init();
            return container.Resolve<T>();
        }

        public static T Resolve<T>(string name)
        {
            Init();
            return container.Resolve<T>(name);
        }
    }
}

5. To call the service from the client you used to do this:

    // Get the mileage claim repository we want to use Entity Framework or ADO.Net.
    IMileageClaimRepository repository = new EF.DataAccess.Finance.Mileage.Repositories.MileageClaimRepository();

    // Initialise the service passing in the data access repository it should use
    MileageClaimService mileageClaimService = new MileageClaimService( repository );

    // Call a method on the service
    DTO.Finance.Mileage.MileageClaim mileageClaimService.GetClaimById( 10 );

but now you would do this:

mileageClaimService = Service.Common.UnityDependencyInjectionHelper.Resolve<Service.Finance.Mileage.MileageClaimService>();

// Call a method on the service
DTO.Finance.Mileage.MileageClaim mileageClaimService.GetClaimById( 10 );

Notice the difference here is we are not specifying the repository to use, it will be automatically injected into the constructor on the service.

6. Lastly you need to add a few lines to the web.config file so the Unity Helper can find the repository.
6a. First you need to add the Enterprise Library Unity section to the configSections.

6b. Next you need to add the mapping to the repository. You do this by adding a Unity block with containers as shown below. You can add this straight after the </configSections>

The ‘type’ effectively says replace any occurrence of the IMileageClaimRepository interface. And the mapTo effectively says with this MileageClaimRepository.

If you ever needed to change the MileageClaimRepository that is being used all you need to do is change the mapTo line e.g.

To change the above which is using the Entity Framework repository (EF.DataAccess…..) to use ADO.Net repository (ADO.DataAccess…..) you would end up with:

Using The Repository Design Pattern For Data Access Code

2009-12-16T15:13:00.002+00:00

In this article we will create a repository for our data base access code. The repository pattern is useful when:
• Some of your clients use Oracle and others use SQL Server you can create a repository for each.
• Your company decides to upgrade to a newer way of doing data base access.

You only need to create a new repository class to do it. E.g. you might have one repository for ADO.Net and one for Entity Framework data access code.

To get started what we are going to do here is create a repository that will contain data base access code to retrieve MileageClaim information.

1. First we need a Data Transfer Object (DTO). This is where the mileage claim data will be placed that we retrieve from the database.

namespace DTO.Finance.Mileage
{
    public class MileageClaim
    {
        public int MileageClaimId { get; set; }
        public string PayrollNumber { get; set; }
        public string ReferenceNumber { get; set; }
        public int? VehicleId { get; set; }
        public int CreatedByPersonId { get; set; }
        public DateTime DateCreated { get; set; }
        public int? UpdatedByPersonId { get; set; }
        public DateTime? DateUpdated { get; set; }
    }
}

You should place the DTO class in a separate class library project as you will reference these classes from many places. I’ve called the project DTO.Finance.Mileage.

2. Define an interface for the repository. Since its going to handle mileage claim data an appropriate name is IMileageClaimRepository.

namespace DataAccess.Finance.Mileage.Interfaces
{
    public interface IMileageClaimRepository
    {
        List<DTO.Finance.Mileage.MileageClaim> GetAllClaimsForEmployee(String employeePayrollNumber);
        DTO.Finance.Mileage.MileageClaim GetClaimByReferenceNumber(String referenceNumber);
        DTO.Finance.Mileage.MileageClaim GetClaimById(Int32 id);
        void ChangeMileageClaimStatus(DTO.Finance.Mileage.MileageClaim claim, DTO.Common.Status status, String userIdentity);
        void Save(ref DTO.Finance.Mileage.MileageClaim claim, String userIdentity);
        void Delete(DTO.Finance.Mileage.MileageClaim claim);
    }
}

Again you should place these interfaces in a separate project as it makes it easier later if/when you create additional mileage claim repositories.

This interface defines the methods that the repository will provide. Because it’s going to contain data base access code it will handle the standard CRUD (create, read, update, delete) methods.

3. Next we need to create the actual repository.

3.1. You should place these data base access classes in a separate project; I’ve called it EF.DataAccess.Finance.Mileage because this repository is going to access the database using Entity Framework. If I had another repository for ADO.Net I’d call it ADO.DataAccess.Finance.Mileage. Inside this project I place all the data base access code including the model diagrams for Entity Framework.

3.2. Inside this project I place the repository class for accessing mileage claim data from the database, so I’ll call it MileageClaimRepository and place it in a Repositories folder. It will implement the IMileageClaimRepository interface.

namespace EF.DataAccess.Finance.Mileage.Repositories
{
    public class MileageClaimRepository : IMileageClaimRepository
    {
        public MileageClaimRepository()
        {
        }

        public List<DTO.Finance.Mileage.MileageClaim> GetAllClaimsForEmployee(String employeePayrollNumber)
        {
            // Data base access code goes here
        }

        public DTO.Finance.Mileage.MileageClaim GetClaimByReferenceNumber(String referenceNumber)
        {
            // Data base access code goes here
        }

        public DTO.Finance.Mileage.MileageClaim GetClaimById(Int32 id)
        {
            // Data base access code goes here
        }

        public void ChangeMileageClaimStatus(DTO.Finance.Mileage.MileageClaim claim, DTO.Common.Status status, String userIdentity)
        {
            // Data base access code goes here
        }

        public void Save(ref DTO.Finance.Mileage.MileageClaim dtoClaim, String userIdentity)
        {
            // Data base access code goes here
        }

        public void Delete(DTO.Finance.Mileage.MileageClaim claim)
        {
            // Data base access code goes here
        }
    }
}

4. We now have our data access layer. To use this layer and to use the separation of concerns principle I’m going to add 1 more layer, a service layer. Note the service contains more methods than the repository (a service layer does not have to map 1 to 1 to the repository layer).

namespace Service.Finance.Mileage
{
    public class MileageClaimService
    {
        IMileageClaimRepository _mileageClaimRepository;

        public MileageClaimService(IMileageClaimRepository mileageClaimRepository)
        {
            _mileageClaimRepository = mileageClaimRepository;
        }

        public List<DTO.Finance.Mileage.MileageClaim> GetAllClaimsForEmployee(String employeePayrollNumber)
        {
            return _mileageClaimRepository.GetAllClaimsForEmployee(employeePayrollNumber);
        }

        public DTO.Finance.Mileage.MileageClaim GetClaimByReferenceNumber(String referenceNumber)
        {
            return _mileageClaimRepository.GetClaimByReferenceNumber(referenceNumber);
        }

        public DTO.Finance.Mileage.MileageClaim GetClaimById(Int32 id)
        {
            return _mileageClaimRepository.GetClaimById(id);
        }

        public void Save(ref DTO.Finance.Mileage.MileageClaim claim)
        {
            String userIdentity = User.Identity.Name;

            if (claim.MileageClaimId == 0)
            {
                // It's a new claim so do some new claim stuff here
                // You could do stuff like automatically set the reference number here
                // Get the status object so we can set the new claim with an initial status of draft
                StatusService statusService = new StatusService();
                DTO.Common.Status status = statusService.GetStatus(
                           (Int32)MileageClaimStatusTypeKeys.MileageClaim,
                           (Int32) Service.Finance.Mileage.Enums.MileageClaimStatusKeys.Draft);

                // We want to make sure that if one of the 2 service calls fail then
                // neither will write any data into the db so lets create a transaction.
                using (TransactionScope scope = new
                         TransactionScope(TransactionScopeOption.Required))
                {
                    // Save any changes to the claim
                    _mileageClaimRepository.Save(ref claim, userIdentity);

                    // Change the claim status to draft
                    ChangeMileageClaimStatus(claim, status);

                    // If no exceptions have been thrown so far then commit the transaction
                    // so everything is saved to the db
                    scope.Complete();
                }
            }
            else
            {
                // It’s an existing claim being edited so save any changes to the claim
                _mileageClaimRepository.Save(ref claim, userIdentity);
            }
        }

        public void Delete(DTO.Finance.Mileage.MileageClaim claim)
        {
            _mileageClaimRepository.Delete(claim);
        }

        public void SubmitClaim(DTO.Finance.Mileage.MileageClaim claim)
        {
            // Save any changes to the claim
            Save(ref claim);

            // Change the claim status to submitted
            StatusService statusService = new StatusService();
            DTO.Common.Status status = statusService.GetStatus(
                        (Int32)MileageClaimStatusTypeKeys.MileageClaim,
                        (Int32)Service.Finance.Mileage.Enums.MileageClaimStatusKeys.Submitted);

            ChangeMileageClaimStatus(claim, status);
        }
    }
}

This service accepts as a parameter on the constructor an interface for an IMileageClaimRepository. When we use the service in our code we tell the service what repository it should use e.g. Entity Framework or ADO.Net repositories.

Because all the repositories use the same interface they will all have the same method names that the service can call so we don’t need to change the service code at all to use different repositories.

5. From a client you just need to reference the service, DTO and the repository you want to use projects. Then to call a method from the client you just:

// Get the mileage claim repository we want to use Entity Framework or ADO.Net.
IMileageClaimRepository repository = new EF.DataAccess.Finance.Mileage.Repositories.MileageClaimRepository();

// Initialise the service passing in the data access repository it should use
MileageClaimService mileageClaimService = new MileageClaimService( repository );

// Call a method on the service
DTO.Finance.Mileage.MileageClaim mileageClaimService.GetClaimById( 10 );

Note: You could use dependency injection (e.g Unity) to work out automatically which repository to use based on settings in a config file and in a future article we will look at doing just that.

Note: You can also use wcf on the service layer with minimal code changes if you wanted to move to a 3-tier architecture, this will be covered in a future article.