Jonathan Stowell

My Application Framework – Part 5 – Pre-compiled Views

jonathan — Mon, 09 Jan 2012 21:39:26 +0000

So whilst I was trying to get up to speed at work and working out how a plugin based system could work. I started to think about the best way to manage my pages. I thought it would be pretty cool if you could compile them into the frontend library. After some research I came across David Ebbo’s RazorGenerator.

I decided to use this and decided to load all of my pages into Windsor on start-up and then pass them into a View Engine that I would write loosely based upon one I found whilst researching David’s implementation. It was quite simple in the end. I simply passed the Windsor container into my View Engine.

1
2
3
4
5
6

private readonly IWindsorContainer _container;

public WindsorPrecompiledViewEngine(IWindsorContainer container)
{
_container = container;
}

Then when a page is requested:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

protected override IView CreatePartialView(ControllerContext controllerContext, string partialPath)
{
string key = GetKey(partialPath, IsMobile(controllerContext));
WebViewPage type = _container.Kernel.Resolve(key);
if (type != null)
{
return new PrecompiledView(partialPath, type, false, FileExtensions);
}

return null;
}

protected override IView CreateView(ControllerContext controllerContext, string viewPath, string masterPath)
{
WebViewPage type;

try
{
type = _container.Kernel.Resolve(GetKey(viewPath, IsMobile(controllerContext)));
}
catch (Exception)
{
type = null;
}

if (type != null)
{
return new PrecompiledView(viewPath, type, true, FileExtensions);
}

return null;
}

The code simply works out the string of the key that would have been used when the view was registered in the container. It also checks to see whether the HTTP Request came from a Mobile Device using an extension method I wrote. If so it formats the key to look for a mobile view. This was an idea I has as I thought it would be pretty cool to use jQuery Mobile to create a mobile version of pages. However this is a future idea really as it’s not worth putting the time into at the moment. Finally if it finds the view it returns it as a Pre-compiled View Object which I believe was taken from David’s example.

This is all plugged in as a Bootstrapping task which adds this View Engine to MVC:

1
2
3
4
5
6
7
8
9
10
11
12
13

public class PrecompiledViewEngineStartupTask : IStartupTask
{
public void Run()
{
var engine = new WindsorPrecompiledViewEngine((IWindsorContainer)Bootstrapper.Container);
ViewEngines.Engines.Add(engine);
}

public void Reset()
{
throw new NotImplementedException();
}
}

Future ideas for this evolve around changing views without having to restart the web server. At the moment if you want to change a page you have to deploy the front end library and restart the server. I came across this Hot Swapping concept from Ayende Rahien and believe it would be possible to do this for swapping out old views for new views in the Windsor container. This could also be possible for any of the libraries dropped into the Plugin folder and could be an interesting feature to work on in the future.

Anyway hope this was interesting!

My Application Framework – Part Four – Brief SOA / Route Registration / Navigation

jonathan — Mon, 09 Jan 2012 13:33:00 +0000

Brief SOA

Front end project can register routes and their navigation structures. The reason I like to register routes is due to the way of working I have undertaken since starting my new job. My new work use a Service Orientated Architecture. They have begun to break down their application into services made up of autonomous components. The components should be able to act independently but can work together by using messaging. Each component has its own entities, own entities, own front-end, own back-end etc.

It works by processing user input validating it, returning errors to the user or sending a message off to the bus. An action which is initiated by a component and processed by the components back-end is called a Command Message. Once processed by the message handler an Event Message is sent out to notify the other components.

Now I have an external message library which form the basis of these event messages allowing applications external to my service to listen to the queue and process any information they may need from certain events occurring. These external messages are extended by internal messages which are use by components inside the service and which may contain more sensitive information than what external sources may be allowed to see.

As in my case each component supplies its own nHibernate session which is built using the components fluent mappings. This should technically allow for your application to be distributed across many computers if demand requires it to be. It should allow it scale a lot more simply than the way traditional systems are built, by just deploying components or services to individual servers and setting them up to send messages to the relevant message queues.

As each component has its own entities and its own set of database tables it should be possible to “shard” the database and distribute it across many computers with no need for it to be in a cluster. Also I’m no expert on this but listening to conversations at work it should be possible to use load balancer’s to forward messages on to many computers running the same service or component. If a component is under strain you should just be able to add another server, setup a service host, listen to the message queues and away you go, you can now satisfy more demand on the popular parts of your system. Again don’t quote me on this, I’m young and still have a long way to go, but it sounds like a brilliant idea to me!

Routes

This basically forms my arguments for each front-end plug-in registering routes. As each autonomous component should be able to act independently, but each component has a slight coupling with the other components in its service. It should hide the concrete routes from any component or service which wishes to access what it offers. This way if you wanted to replace a component you could use the same registered routes and just point them to the new concrete routes in your new plug-in. I have managed to do this for web requests initialised by the user but not when I attempt to pull components into a host component using RenderAction. RenderAction does not seem to process the request through the routing engine so I get an issue in the Windsor Controller Factory. If anyone knows more about this process it would be good if you could get in contact with me and give me some advice on this one.

A Route Registration appears like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class RegisterRoutes : IRegisterRoutes
{
public void Register(RouteCollection routes)
{
routes.MapRoute(
"RoleCreate",
"Role/Create",
new { controller = "RoleManagement", action = "Create" }
);

routes.MapRoute(
"RoleEdit",
"Role/Edit/{id}",
new { controller = "RoleManagement", action = "Edit", id = "" }
);

routes.MapRoute(
"RoleRename",
"Role/Rename/{id}/{name}",
new { controller = "RoleManagement", action = "Edit", id = "", name = "" }
);

routes.MapRoute(
"RoleDelete",
"Role/Delete/{id}",
new { controller = "RoleManagement", action = "Delete", id = "" }
);
}
}

A class simply implements the IRegisterRoutes interface and register routes as if it would in the Global.asax. Then on start-up these classes are resolved from Windsor and executed passing in the RouteTable.

Navigation

Front end libraries can also register their navigation:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

public class RegisterNavigation : IRegisterNavigation
{
public NavigationNode Path
{
get
{
NavigationNode host = new NavigationNode
{
Action = "Index",
Controller = "UserHost",
Name = "User System"
};

NavigationNode roles = new NavigationNode
{
Controller = "Roles",
Name = "Role Management"
};

host.Children.Add(roles);

return host;
}
}

public string[] Roles
{
get { return new[] { "Creator", "Admin", "UserAccess" }; }
}

public bool RequireAllRoles
{
get { return false; }
}
}

This defines a tree structure of Navigation Nodes which include the details to create the navigation links, and the security information to access the part of the system.

All of these navigation registrations are passed into a class which creates a navigation tree on start-up. This class is used by the navigation controller to render the navigation for each user. Upon request the class loops over each registration and adds it to a navigation data structure if the user is privileged enough to access the part of the system the registration describes.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public DataStructures.Navigation GetNavigation(ThreeBytesPrincipal principal)
{
var result = new DataStructures.Navigation();

foreach (var nav in container.ResolveAll().OrderBy(x => x.Path.Name))
{
if (nav.Roles.Length > 0)
{
if (principal != null)
{
if (nav.RequireAllRoles)
{
if (!principal.IsInAnyRoles(nav.Roles))
continue;
}
else
{
if (!principal.IsInAnyRoles(nav.Roles))
continue;
}

result.Add(nav);
}
}
else
{
result.Add(nav);
}
}

return result;
}

The Navigation Data Structure recursively loops over the path supplied by the registration adding it to a Navigation Nodes list, merging nodes of the same path until they differ.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public class Navigation
{
public IList NavigationNodes { get; set; }

public Navigation()
{
NavigationNodes = new List();
}

public void Add(IRegisterNavigation navigation)
{
AddInternal(navigation.Path);
}

private void AddInternal(NavigationNode path)
{
AddRecursive(NavigationNodes, path);
}

private void AddRecursive(IList navigationNodes, NavigationNode toAdd)
{
if (navigationNodes.Contains(toAdd))
{
foreach (var node in toAdd.Children)
{
AddRecursive(navigationNodes.Single(x => x.Name == toAdd.Name).Children, node);
}
}
else
navigationNodes.Add(toAdd);
}
}

I then have a HTML Helper which outputs the relevant HTML to complement the structure built by this class.

My Application Framework – Part Three – Windsor Registration and it’s role in Plug-ins

jonathan — Mon, 09 Jan 2012 13:29:52 +0000

I previously mentioned the bootstrapping task registering everything in classes which implement IWebWindsorRegistration and IBusWindsorRegistration. The way I structure my applications is to have a library of interfaces which perform a specific task and then a library of concrete implementations of those interfaces.

For example I divide my application up into Data classes which use generic repositories to provide data access via nHibernate. Service classes which provide a caching layer on top of these repositories. Validation libraries which provided validation for the Domain Objects. Frontend libraries which consume the services and provide a means to handle web requests, serve pages and fire off messages for the Backend Message Handlers to process. I will get into this in a later article in more detail.

However each concrete library has an Installers folder which contains a class which implements IWebWindsorRegistration and IBusWindsorRegistration and may include something like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public void Install(IWindsorContainer container)
{
container.Register(
AllTypes.FromThisAssembly().BasedOn().Configure(
component =>
{
component.Named(component.Implementation.Name);
component.LifeStyle.Is(LifestyleType.PerWebRequest);
}).WithService.Base(),
AllTypes.FromThisAssembly().BasedOn().Configure(
component =>
{
component.Named(component.Implementation.Name);
component.LifeStyle.Is(LifestyleType.PerWebRequest);
}).WithService.Base(),
AllTypes.FromThisAssembly().BasedOn().Configure(
component =>
{
component.Named(component.Implementation.Name);
component.LifeStyle.Is(LifestyleType.PerWebRequest);
}).WithService.Base()
);
}

Upon start-up the Windsor Bootstrapper extension executes all of these classes and installs the dependencies into the container. So we have libraries being installed from outside of the bin directory into the container for our application to serve up.

The way this works in the context of serving up content is as so:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public void Install(IWindsorContainer container)
{
container.Register(
AllTypes.FromThisAssembly().BasedOn().Configure(
component =>
{
component.Named(component.Implementation.Name);
component.LifeStyle.Is(LifestyleType.Transient);
}).WithService.Base(),
AllTypes.FromThisAssembly().BasedOn().Configure(
component =>
{
component.Named(ViewKeyGenerator.GetViewKey(component.Implementation.FullName));
}).WithService.Base(),
AllTypes.FromThisAssembly().BasedOn().Unless(x => x.IsAbstract).Configure(x => x.LifeStyle.Singleton),
AllTypes.FromThisAssembly().BasedOn().Unless(x => x.IsAbstract).Configure(x => x.LifeStyle.Singleton),
AllTypes.FromThisAssembly().BasedOn().Unless(x => x.IsAbstract).Configure(x => x.LifeStyle.Transient)
);
}

Each frontend project registers all of its controllers, all of its Web Pages using a method I wrote to format it’s implementation name, all of its route registrations, all of its navigation registrations and finally all of its commands that it uses to process user input, ensure its valid before sending a message off to the Bus.

With everything in the container when a request for a controller comes in the Windsor Controller Factory resolves it from the container. When the controller returns its page the page is found in the container and rendered as the result of the request.

My Application Framework – Part Two – Assembly Resolve

jonathan — Mon, 09 Jan 2012 13:27:25 +0000

In order to use code which exists outside the bin directory we must write a class that loads these assemblies using reflection and finds these assemblies when the system requires them.

The ResolveAssemblies class scans a supplied directory for libraries matching supplied patterns. In my case it scans a Plugins folder for assemblies that begin with ThreeBytes.

1
2
3
4
5
6
7
8
9
10
11
12
13

It then attempts to load these assemblies and then register them in a dictionary.

1
2
3
4
5
6
7
8
9
10
11
12
13

foreach (var file in files)
{
var assembly = Assembly.LoadFrom(file.FullName);
assembly.GetTypes();
RegisterAssembly(assembly.FullName, assembly);
}

private void RegisterAssembly(string assemblyName, Assembly assembly)
{
var comma = assemblyName.IndexOf(',');
pluginAssembliesByFullName[assemblyName] = assembly;
pluginAssembliesByFullName[comma == -1 ? assemblyName : assemblyName.Substring(0, comma)] = assembly;
}

Finally our start-up task adds this method when the system needs to find an assembly.

1
2
3
4

private bool TryGetAssembly(string assemblyName, out Assembly assembly)

{
return PluginAssembliesByFullName.TryGetValue(assemblyName, out assembly);
}

Which simply looks in the dictionary for the assembly the system is looking for.

My Application Framework – Part One – Startup

jonathan — Mon, 09 Jan 2012 13:23:34 +0000

When one of my websites or service hosts starts up it executes a series of start-up tasks to prime the application for run time. I discovered this great bootstrapping library on codeplex, cleverly named bootstrapper written by luisbocaletti. Using this framework you can create several classes that implement IStartupTask which will execute on start-up, as long as you include the bootstrapper initialisation code.

You can also write dependency injection container extensions for it to install your dependencies into a container of your choice on start-up. I based my Windsor extension on the one I found on the Bootstrapper website. However I customised it to my needs. I have customised it to take an environment setting which will then set the context of whether the bootstrap operation is occurring for a web based system or a bus based system. It also takes the class I wrote to store assemblies that are not stored in the bin directory (this will be explained in a later article).

Upon execution of the first part of the bootstrapping initialisation:

1	Bootstrapper.With.Windsor(AssemblyResolver, BootstrapEnvironment.WEB)

The code registers every class that implements an IRegister interface into the container. Then depending on the context it runs every class that registers dependencies into Windsor. In the case of the Web it executes every Register(IWindsorContainer container) for every class that implements IWebWindsorRegistration, in the case of the service host it executes every IBusWindsorRegistration.

This allows one to specify different lifestyles for different dependencies. For example in a web context you are likely to want to manage your data access classes on a per web request basis. However in a service host context you may want to specify a per thread lifestyle.

1
2
3
4
5
6

Bootstrapper.With.Windsor(AssemblyResolver, BootstrapEnvironment.WEB).And.StartupTasks()
.UsingThisExecutionOrder(s => s
.First()
.Then()
.Then().TheRest())
.Start();

Once registering everything into the container the bootstrapper begins the start-up tasks. Beginning with adding a method to the app domain assembly resolve method which points to the GetAssembly method in the class I have to manage assemblies which are loaded from outside the bin folder. Now when an assembly is required it will also execute this method and return the assembly if it is located within the dictionary where the external libraries are loaded.

1
2
3
4

public void Run()
{
AppDomain.CurrentDomain.AssemblyResolve += (a, args) => MvcApplication.AssemblyResolver.GetAssembly(args.Name);
}

The bootstrapper then executes the start-up task to configure nServiceBus allowing messages to be sent from the website to a configured MSMQ queue and picked up by the service host (Will be covered by a later article).

There are then a series of other start-up tasks. I have used Fluent Validation on this project as I found the Data Annotations framework quite limiting. There are going to be regular situations where you want more than simple validation and you need to validate against a database. For example when a register attempts to create an account, does a user with their details already exists? As Data Annotations use filters it is not possible to inject a repository or nHibernate session into the filter and validate against a database. Fluent Validation however does allow you to and I believe it still creates unobtrusive javascript for the simple validation rules. Anyway one of the start up tasks for the web context adds a new Validation Provider to the ModelValdationProviders class. All validations are also installed into my Windsor Container using my Windsor Installers allowing them to be injected into any class.

There is also a Logging Start-up Task which registers a global filter I wrote to handle errors. If an exception is unhanded it sends a message to the logging queue for the logging system to process.

There is the standard overriding of the controller factory to resolve controllers from the Windsor container. This works nicely with the plug-in approach I will explain in later articles as with my IWebWindsorInstallers you can register the controllers you create in the plug-ins into the container which are loaded from outside the bin directory.

There is a task to register routes into the routing table. Routes can be registered by the plug-in libraries by implementing an IRegisterRoutes interface I have created and installing them into the container using the previously mentioned IWebWindsorInstaller. The start-up task resolves all of the classes which implement IRegisterRoutes and registers all the defined routes into the route table.

There are two more tasks for the process of starting the Web Application. The penultimate one is adding a view engine to the MVC Framework. The view engine allows the system to return razor views which have been registered into the Windsor Container. Using David Ebbo’s Razor Generator each plug-in compiles their views which are then registered into the container during the install tasks. Then upon each request the view is searched for in the container before looking in the standard file disk locations.

The final task creates a navigation structure. Each plug-in can register a navigation structure in the form of a tree structure. They can define things such as the roles required to access that component. Upon start-up the container is passed to a class which upon each requests outputs a navigation structure using the navigation information provided by each plug-in. Obviously it does not include paths which the current user does not have access rights for. It does however merge paths of the same structure until they differ, for example on the final leaf node.

Now some of you maybe here thinking, he’s talked a lot about the Web Context but what about the Service Host. Where did that go? The service host also uses the bootstrapper and installs all the classes that implement IBusWindsorInstaller. However it only really has the start-up task to resolve assemblies from outside of the bin directory.

Apologies for quickly brushing over the tasks. I have done so as they pretty much each deserve their own article, hence the part one. These will be coming in the forthcoming weeks however for now I just wanted to make a start and where better than how it starts up. Hopefully how things work will become clearer as I begin to write about how all of these pieces slot together.

My Application Framework

jonathan — Thu, 29 Dec 2011 20:00:01 +0000

Going to try and keep this one short as I don’t want to bore anyone!

About six months ago now I began attempting to create my own framework of systems that I could use when building websites. My vision was to have a core set of libraries that could be used across any system for example I have Generic Repositories which allow data access for any entity that implements my IBusinessObject interface. I also have a set of Generic Service classes for my Business Objects which in time will hopefully act as a Caching layer when I get time to write a Memcached implementation. I also wanted to have a User, Logging and Email system which could also be used by any application and which would use my core libraries.

Anyway I began creating this in a traditional way having a relational database etc etc, but then I got a new job with Illy Systems and met some extremely intelligent developers. This lead me to rethink my Framework and I began to work in a new way.

The guys at work had just started using nServiceBus in a “Pluggable” way. I found this really interesting and whilst they use monorail for their website frontend. I wanted to create a way to do it with ASP MVC.

So this is how I’ve done it. When the Web / Service Bus applications start up they scan a certain directory for assemblies. In the Web project it is {WebDir}/Plugins in the service bus this is located in the bin/Plugins. It loads all of these assemblies into a dictionary. Once complete the application executes a series of startup tasks starting with scanning all of the assemblies in the dictionary for Windsor Installers. I have two types of installers a IWebInstaller and IBusInstaller and you set the context upon calling the Bootstrapper in the Global.asax. This then installs everything you tell it to into the Windsor Container from the plugin assemblies.

This includes all Repositories, Services, Validations, Configuration, Controllers, Razor Views where I have used David Ebbo’s Razor Generator to compile them, and then two interfaces I have created call IRegisterRoutes and IRegisterNavigation (We shall get to these in a bit).

It then adds a new method to the app domain assembly resolve event handler which exists in the class which contains the dictionary of assemblies. Now when the application needs an assembly it will check the dictionary as well as the bin folder/gac.

It then starts nServiceBus and registers it into the Windsor Container.

It then overrides the View Engine with one that looks in the Windsor Container for the page instead of on the file system.

It then overrides the Model Validation and uses the Fluent Validation framework instead.

It then initialises Logging using a Global Filter which will send a Message to the Logging queue for the logging service host to handle whenever there is an unhandled exception.

It then Resolves all of the IRegisterRoutes from the container and adds them to the Routes Table. I thought this could be a good idea for developing in a plugin / soa way as each of your components can consume other components and using routes can mask the actual implementation of these controllers, making it easier to swap in and out new plugins when needed. However I have only managed to get this to work when a request comes in from a browser. When I use ActionResult which I believe creates a new request but only in an internal way it doesn’t seem to use the routing engine (Help with this bit would be appreciated!)

It then also resolves all of the IRegisterNavigation implementations and builds an overall Navigation structure from them which is then registered into the container.
Finally it overrides the Controller Factory with one that resolves the controllers from Windsor.

The application is being created in a way where you have Services which are made up of Autonomous Components which act independently of each but which share a set of messages in order to maintain their own datasets and perform what they need to do depending on the events which have happened in the system. Some of these messages inherit from an external source of messages which is information which is deemed to be ok to share with other services. These could be services you build or services someone else has built who doesn’t even know you. This makes it necessary to think about what you are exposing to the external world.

Basically in a normal process this is what happens. User performs an action using an interface. This gets mapped to a controller action which then populates a pre command. The pre command populates an object and validates it. If the object is not valid the controller returns the Validation Results from the pre command and validation messages are shown for the user to try again. On a valid attempt the pre command then sends a message on to the Bus and releases the request. The message sent is generally a command message which is handled by one backend message handler. The handler validates the process again and ensures its still ok to complete this action. If it isn’t it throws an exception, if it is it persists the action and then publishes an event message. It’s this event message that other components listen to. As the internal messages inherit from the external messages. Other messages in the same service can get the extra information exposed to them and external components still receive the messages with less information exposed to them. These handlers then perform whatever they need to do.

Once complete the front end is now up to date with the backend but the user hasn’t had to wait for the process to complete.

The reason for developing in this way is to create a system that can easily be distributed and hence allow it to scale (This is perhaps for another article or your own reading).

Obviously the user is going to experience an out of sync system. However I have a few ideas on how caching could be used to “fake” their actions and make it appear to be completed when the backend hasn’t actually processed it yet.

Anyway the framework is far from complete and apologies for a scattered article. I just wanted to get what I had been playing with out there and perhaps get interest from others on helping with it.

If you are interested in helping with this perhaps comment on this article or contact me on github the repository is located here, and I will get back to you!

Cheers,
Jon

My First Data Access Layer Amends Part 1

jonathan — Sun, 21 Aug 2011 18:52:34 +0000

Ok so yesterday I posted about a Data Access Layer (DAL) I had been working on (Article Here). Today I came across this article. The Identity Map pattern it uses taken from Martin Fowlers blog is a great idea and I decided to implement this in my DAL.

I also moved away from using an abstract GetAll, Add, Update, Delete etc method and instead decided to use the template pattern to perform these operations. This then means that when I need to remove objects from the object cache of the Identity Map implementation I can do so in one place instead of having to do so in every repository I create.

The previously abstract Update method now looks like the below. With the object being updated removed from the cache if the ExecuteWrite method is successful.

1
2
3
4
5
6
7
8
9
10

protected abstract CommandType GetUpdateCommandType();
protected abstract string GetUpdateCommandText();
protected abstract ICollection GetUpdateParameters(T item);

public bool Update(T item)
{
bool result = ExecuteWrite(GetUpdateCommandType(), GetUpdateCommandText(), GetUpdateParameters(item));
if (result) Cache.Remove(item);
return result;
}

The specifics to execute the ExecuteWrite method are now provided in the repositories by the implementation of the abstract methods you can see above.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

protected override CommandType GetUpdateCommandType()
{
return CommandType.StoredProcedure;
}

protected override string GetUpdateCommandText()
{
return "UpdatePerson";
}

protected override ICollection GetUpdateParameters(Person item)
{
return _paramCollectionRepository.GetPersonIdFirstNameLastNameEmailParamCollection(item.PersonId,
item.FirstName,
item.LastName,
item.Email);
}

I have implemented my Object Cache in the mapping classes of my DAL like so.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public override Person Map(IDataRecord record)
{
try
{
int id = (DBNull.Value == record[_columnProvider.PersonID]) ? 0 : (int) record[_columnProvider.PersonID];

var cachedEntity = Cache.TryToFind(typeof(Person), id);
if (cachedEntity != null) return (Person)cachedEntity;

Person p = new Person();

p.PersonId = id;
p.FirstName = (DBNull.Value == record[_columnProvider.FirstName]) ? string.Empty : (string)record[_columnProvider.FirstName];
p.LastName = (DBNull.Value == record[_columnProvider.LastName]) ? string.Empty : (string)record[_columnProvider.LastName];
p.Email = (DBNull.Value == record[_columnProvider.Email]) ? string.Empty : (string)record[_columnProvider.Email];

Cache.Store(typeof(Person), id, p);

return p;
}
catch (Exception)
{
throw;
}
}

If the object can be located in the cache we no longer continue with mapping from the database and instead just return the object from the cache. If it is not in the cache we map the object and chuck it in there.

My object cache is just taken from the article above. However I include the code below.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

public interface IObjectCache
{
object TryToFind(Type type, object id);
void Store(Type type, object id, object entity);
void ClearAll();
void RemoveAllInstancesOf(Type type);
void Remove(object entity);
}

public class ObjectCache : IObjectCache
{
private readonly Dictionary> cache = new Dictionary>();

public object TryToFind(Type type, object id)
{
if (!cache.ContainsKey(type)) return null;

string idAsString = id.ToString();
if (!cache[type].ContainsKey(idAsString)) return null;

return cache[type][idAsString];
}

public void Store(Type type, object id, object entity)
{
if (!cache.ContainsKey(type)) cache.Add(type, new Dictionary());

cache[type][id.ToString()] = entity;
}

public void ClearAll()
{
cache.Clear();
}

public void RemoveAllInstancesOf(Type type)
{
if (cache.ContainsKey(type))
{
cache.Remove(type);
}
}

public void Remove(object entity)
{
var type = entity.GetType();

if (!cache.ContainsKey(type)) return;

string keyToRemove = null;

foreach (var pair in cache[type])
{
if (pair.Value == entity)
{
keyToRemove = pair.Key;
}
}

if (keyToRemove != null)
{
cache[type].Remove(keyToRemove);
}
}
}

Updated Source Code Here.

This will probably change in the future as I will probably create more realistic Domain objects that inherit from an abstract BusinessObject class which contains the primary key and implements an interface. Which may allow me to structure things in a nicer way. However for the time being this is just me playing around with some ideas which I will hopefully build upon over time.

My First Data Access Layer

jonathan — Sat, 20 Aug 2011 18:00:53 +0000

Mainly throughout the years I have used ORM’s (Object Relational Mappers) such as LINQ to SQL, Entity Framework Code First and nHibernate to handle my database access. I mean why recreate the wheel when these tools make accessing data and returning objects so simple? With all three of them now you can even write your queries in LINQ and will translate it to the relevant SQL for you! They also provide a nice abstraction from your underlying database vendor making it easy to switch from SQL Server to MySQL to Oracle. So you might ask, why am I even writing about creating a Data Access Layer from scratch? Why am I not just content with using nHibernate (My favourite from the 3 mentioned)? Well the answer is curiosity. I want to know how things work and I feel the best way to gain that understanding is to play around and write your own.

I also hear a lot of talk at work and from other more experienced developers about their love of just having a Data Access Object and just calling Stored Procedures. They feel you have a lot more control over the SQL you are running on the database and you experience better performance from this. From what I’ve read I’m aware that ORM’s generate SQL on the fly which does have it’s performance draw backs. Obviously when running a stored procedure no SQL needs to be generated meaning better performance. However you can cache the SQL generated by ORM’s to improve its performance and I know there are several features in nHibernate you can use to improve its performance. It’s just learning what they are! Which I am hoping to do at my new job where they claim to be hardcore nHibernate users!

Anyway my attempt at Data Access so far. I’ve only spent a couple days working on this so don’t be harsh! I have tried to take things I have learnt from using Generic Repository pattern using ORM’s and use it with what I have read about normal Data Access Layers. Perhaps one of the better article’s I read on the subject was this one here written by Matthew Cochran.

So I will start by explaining my Core.Abstract class library. Here I have the contracts which provide the Core of my data access. This is not specific to any project, implementation or database vendor. In this project I have a IDatabaseFactory which will simply provide an IDbConnection.

1
2
3
4

public interface IDatabaseFactory
{
IDbConnection DbConnection { get; }
}

I also have an IMapper interface which will be used for classes which will map my domain objects to the relevant database tables. Implementers of this interface will be able to return single entities or collections of entities from a passed in IDataReader object.

1
2
3
4
5
6

public interface IMapper where T : class
{
T Map(IDataRecord record);
T MapSingle(IDataReader reader);
ICollection MapCollection(IDataReader reader);
}

Next I have the first of three generic interfaces which will provide the main access for different types of domain objects. The first is IObjectReaderBase which will provide read access for a Object. The next IObjectWriterBase will provide create, update and delete operations for a domain object. The last IObjectKeyReaderBase provides a GetById method for Domain Objects which have a single primary key.

1
2
3
4
5
6
7
8
9
10
11

public interface IObjectReaderBase where T : class
{
IDatabaseFactory DatabaseFactory { get; }
IDbConnection Connection { get; }
IMapper Mapper { get; }
ICollection GetAll();
T ExecuteSingle(CommandType commandType, string commandText);
T ExecuteSingle(CommandType commandType, string commandText, ICollection parameters);
ICollection ExecuteCollection(CommandType commandType, string commandText);
ICollection ExecuteCollection(CommandType commandType, string commandText, ICollection parameters);
}

1
2
3
4
5
6
7
8
9
10
11
12

public interface IObjectWriterBase : IObjectReaderBase where T : class
{
bool Add(T item);
bool Add(IEnumerable items);
bool Update(T item);
bool Update(IEnumerable items);
bool Delete(T item);
bool Delete(IEnumerable items);
IUnitOfWork UnitOfWork { get; }
bool ExecuteWrite(CommandType commandType, string commandText);
bool ExecuteWrite(CommandType commandType, string commandText, ICollection parameters);
}

1
2
3
4

public interface IObjectKeyReaderBase : IObjectWriterBase where T : class
{
T GetById(int id);
}

Finally I have an IUnitOfWork Interface which will encapsulate my transactions.

1
2
3
4
5
6
7
8

public interface IUnitOfWork
{
IDbTransaction Transaction { get; }
bool IsInTransaction { get; }
void BeginTransaction();
void RollBackTransaction();
bool CommitTransaction();
}

Ok on to the implementation of this which can be found in the Core.Concrete class library. The Database Factory is fairly simple and it just returns a new SqlConnection.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class DatabaseFactory : IDatabaseFactory
{
private IDbConnection _dbConnection;

public IDbConnection DbConnection
{
get
{
if (_dbConnection == null)
_dbConnection = new SqlConnection(ConfigurationManager.ConnectionStrings["myConnectionString"].ConnectionString);

return _dbConnection;
}
}
}

Object Reader Base contains the Unit of Work implementation, the IDbConnection which it gets from the Database Factory and the domain objects Mapper class. The class needs the Database Factory and Mapper class to be instantiated. The class contains two fairly similar methods. ExecuteSingle and ExecuteCollection which do exactly what they are called. ExecuteSingle is intended to be used for things such as GetById or a query that will only return one object. ExecuteCollection things such as GetAll or a method that will return many objects. As they are fairly similar and the only difference is which Mapping method is called I will only explain one. Fairly standard code it just creates a command from the passed in Command Type (E.g. Stored Procedure), Command Text (E.g. Stored Procedure Name) and Command Parameters (E.g. Stored Procedure Variables). This will all be specified in the Domain Objects repository class (Explained Later). If the process is in a transaction we assign the transaction to the command, we that add the parameters to the command. If the process is in a transaction we do not open the connection as it will already be open and will cause an exception (You need to keep the connection open for the entire transaction). If not in a transaction we open the connection ready to fire the command to the database. Once executed we call our Mapping method to return an object. We then close or not close our connection depending on the transaction status.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

public T ExecuteSingle(CommandType commandType, string commandText, ICollection parameters)
{
IDbCommand command = Connection.CreateCommand();
command.Connection = Connection;
command.CommandText = commandText;
command.CommandType = commandType;

if (UnitOfWork.IsInTransaction)
command.Transaction = UnitOfWork.Transaction;

if (parameters != null)
{
foreach (var param in parameters)
{
command.Parameters.Add(param);
}
}

try
{
if (!UnitOfWork.IsInTransaction)
Connection.Open();

using (IDataReader reader = command.ExecuteReader())
{
try
{
return Mapper.MapSingle(reader);
}
catch (Exception)
{
throw;
}
finally
{
reader.Close();
}
}
}
catch (Exception)
{
throw;
}
finally
{
if (!UnitOfWork.IsInTransaction)
Connection.Close();
}
}

We also declare an abstract GetAll() method which will be implemented by the inheriting repository. This way we can provide the name of the stored procedure we want to execute.

1	public abstract ICollection GetAll();

Next the ObjectWriterBase contains a method similar to ExecuteSingle and ExecuteCollection called ExecuteWrite. This method simply calls ExecuteNonQuery instead of executing the command and using IDataReader. This method will be used for our Create, Update and Delete operations. Again we declare abstract Add, Update and Delete methods so the inheriting class can provide the appropriate stored procedure name and parameters. We also have methods that allow a collection to be passed to them to Add, Update or Delete many records at once.

1
2
3
4
5
6
7
8

public virtual bool Add(IEnumerable items)
{
foreach (var item in items)
{
Add(item);
}
return true;
}

Finally our ObjectKeyReaderBase just declares an abstract GetById method for the same reasons as previously.

1	public abstract T GetById(int id);

The unit of work implementation is fairly simple allowing one to Begin a Transaction. Which will also open the connection for you.

1
2
3
4
5

public void BeginTransaction()
{
_connection.Open();
_transaction = _connection.BeginTransaction();
}

Rollback a transaction.

1
2
3
4
5

public void RollBackTransaction()
{
_transaction.Rollback();
_connection.Close();
}

Commit a transaction and run the relevant rollback if it doesn’t work.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public bool CommitTransaction()
{
if (_transaction == null)
{
throw new ApplicationException("Cannot roll back a transaction while there is no transaction running.");
}

try
{
_transaction.Commit();
_connection.Close();
return true;
}
catch (Exception ex)
{
_transaction.Rollback();
return false;
}
finally
{
ReleaseCurrentTransaction();
}
}

It also contains a flag to tell you whether you are currently in a transaction.

1
2
3
4

public bool IsInTransaction
{
get { return _transaction != null; }
}

So now lets look at how we actually use this in relation to an object. I have a simple Person object in Entities.Conrete.

1
2
3
4
5
6
7

public class Person
{
public int PersonId { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public string Email { get; set; }
}

I then have a IPersonRepository interface in Repositories.Abstract. So far this interface just inherits from IObjectKeyReaderBase as I haven’t created any specific Person queries. I still like to create a new interface however just encase I do want to add additional methods in the future.

1 2	public interface IPersonRepository : IObjectKeyReaderBase { }

Finally PersonRepository is implemented in Repositories.Concrete. This class provides the Stored Procedure names and parameters to the underlying execute methods. It uses an IPersonParamCollectionRepository to get the collection of parameters. I have done this to try and create a reusable way of getting parameter collections for stored procedures which require the same parameters.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

public class PersonRepository : ObjectKeyReaderBase, IPersonRepository
{
private IPersonParamCollectionRepository _paramCollectionRepository;

public PersonRepository(IDatabaseFactory databaseFactory, IMapper mapper, IPersonParamCollectionRepository paramCollectionRepository)
: base(databaseFactory, mapper)
{
_paramCollectionRepository = paramCollectionRepository;
}

public override ICollection GetAll()
{
return ExecuteCollection(CommandType.StoredProcedure, "GetAllPeople");
}

public override Person GetById(int id)
{
ICollection collection = _paramCollectionRepository.GetPersonIdParamCollection(id);
return ExecuteSingle(CommandType.StoredProcedure, "GetPersonById", collection);
}

public override bool Add(Person item)
{
ICollection collection =
_paramCollectionRepository.GetFirstNameLastNameEmailParamCollection(item.FirstName,
item.LastName,
item.Email);

return ExecuteWrite(CommandType.StoredProcedure, "AddPerson", collection);
}

public override bool Update(Person item)
{
ICollection collection =
_paramCollectionRepository.GetPersonIdFirstNameLastNameEmailParamCollection(item.PersonId,
item.FirstName,
item.LastName,
item.Email);

return ExecuteWrite(CommandType.StoredProcedure, "UpdatePerson", collection);
}

public override bool Delete(Person item)
{
ICollection collection = _paramCollectionRepository.GetPersonIdParamCollection(item.PersonId);
return ExecuteWrite(CommandType.StoredProcedure, "DeletePerson", collection);
}
}

Now lets see the Parameter Collection Repository. In a similar method to the Repository using this to group reusable parameters together. The creation of the parameters falls to a separate class. This way if anything with an individual parameter changes, such as its data type, it only needs to be changed in one place!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class PersonParamCollectionRepository : IPersonParamCollectionRepository
{
private IPersonParamRepository _paramRepository;

public PersonParamCollectionRepository(IPersonParamRepository paramRepository)
{
_paramRepository = paramRepository;
}

public ICollection GetPersonIdParamCollection(int id)
{
ICollection collection = new Collection();
collection.Add(_paramRepository.GetPersonIdParam(id));

return collection;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class PersonParamRepository : IPersonParamRepository
{
private readonly IPersonColumnProvider _columnProvider;
private readonly IDataParamHelper _dataParamHelper;

public PersonParamRepository(IPersonColumnProvider columnProvider, IDataParamHelper dataParamHelper)
{
_columnProvider = columnProvider;
_dataParamHelper = dataParamHelper;
}

public IDataParameter GetPersonIdParam(int id)
{
return _dataParamHelper.BuildDataParameter(DbType.Int32, _columnProvider.PersonID, id);
}
}

The BuildDataParameter method simply builds a parameter. Again if anything changes here it is interfaced so a new implementation can be provided and injected where it is used using Dependency Injection.

1
2
3
4
5
6
7
8

public IDataParameter BuildDataParameter(DbType dataType, string parameterName, object value)
{
IDataParameter param = new SqlParameter();
param.DbType = dataType;
param.Value = value ?? DBNull.Value;
param.ParameterName = parameterName;
return param;
}

The Person Column Provider class simply encapsulates the names of the columns on the Person table. Again I’ve done this so if a column name changes it only needs to be changed in this one class. Whenever I use a column name such as when I create the Data Parameters it get the name from this class.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class PersonColumnProvider : IPersonColumnProvider
{
public string PersonID
{
get { return "PersonID"; }
}

public string FirstName
{
get { return "FirstName"; }
}

public string LastName
{
get { return "LastName"; }
}

public string Email
{
get { return "Email"; }
}
}

Finally perhaps a bit out of context but lets have a look at the Person Mapper class. It inherits from MapperBase which can be located in Core.Concrete.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

public abstract class MapperBase : IMapper where T : class, new()
{
public abstract T Map(IDataRecord record);

public T MapSingle(IDataReader reader)
{
T item = null;

while (reader.Read())
{
item = Map(reader);
}

return item;
}

public virtual ICollection MapCollection(IDataReader reader)
{
ICollection collection = new Collection();

while (reader.Read())
{
try
{
collection.Add(Map(reader));
}
catch (Exception)
{
throw;
}
}

return collection;
}
}

A mapper class then just implements Map allowing it to return a single object or a collection of objects. Below simply either populates an attribute from the record that is returned from the database or populates it to an empty value if there is no record returned.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

public class PersonMapper : MapperBase
{
private readonly IPersonColumnProvider _columnProvider;

public PersonMapper(IPersonColumnProvider columnProvider)
{
_columnProvider = columnProvider;
}

public override Person Map(IDataRecord record)
{
try
{
Person p = new Person();

p.PersonId = (DBNull.Value == record[_columnProvider.PersonID]) ? 0 : (int)record[_columnProvider.PersonID];
p.FirstName = (DBNull.Value == record[_columnProvider.FirstName]) ? string.Empty : (string)record[_columnProvider.FirstName];
p.LastName = (DBNull.Value == record[_columnProvider.LastName]) ? string.Empty : (string)record[_columnProvider.LastName];
p.Email = (DBNull.Value == record[_columnProvider.Email]) ? string.Empty : (string)record[_columnProvider.Email];

return p;
}
catch (Exception)
{
throw;
}
}
}

I hope this helps someone who is just starting to look at data access layers. If anyone would like to provide comments below it would be much appreciated. Any suggestions on improvements or enhancements would be very welcome. I’m trying to learn how to do things the right way and the best way.

My next steps for this is to discover a way to map relationships and collections in an elegant way. Hopefully my research into this may lead me to enhancing this project to.

I provide the source code below. However it does contain a Caching Project and Web Project which I was just playing around with. Those two are for a later discussion! Enjoy!

Source Code: Here

PS: If anyone doesn’t have a version of Visual Studio where you can open Database Projects leave a comment and I will generate a SQL script.

Entity Framework Code First CTP5

jonathan — Sun, 22 May 2011 11:53:14 +0000

Entity Framework Code First (EFCF) seems to be Microsoft’s answer to nHibernate. I first came across the technology a couple months ago watching a Channel 9 video from a recent MVC Conference presented by Chris Zavaleta (twitter) and was intrigued as to how useful this could be. The answer I now feel is very useful so keep reading!

Basically EFCF generates your relational database model from your object model. Which when in the early stages of a project I feel can be extremely useful. Being able to change your object model extremely quickly without the worries of creating a new database table, adding new columns to an existing table, updating your ORM or even having to rewrite, or even write new classes in your Data Access Layer (DAL) to handle the mapping of your relational domain to your object domain (Big Hassle!).

Having previously used LINQ to SQL as my DAL I always felt slightly frustrated with it. I like to separate things out and whilst LINQ to SQL provided a convenient way to quickly develop projects shielding me from the ugliness of having to write my own DAL, I always wanted more separation of my entities. I also found it frustrating with it not automatically loading Collections an entity may contain. Yes I can probably guess there are ways to do this but if I’m honest I didn’t have to find out in the end because EFCF came along.

I found EFCF maps my Object Domain to a relational database very well. The only difficulty I had is when I wanted to include additional attributes in join tables. This lead me to research into configuration files for EFCF and it turns out that if you want to have more control over how EFCF maps your object domain to the database you can. I’ve never really worked with nHibernate but have seen some examples of it on projects at work and it would seem that these configuration files are very much like the mapping xml files nHibernate uses. Apart from the EFCF configuration files are written in C# using lambda expressions to define the mappings.

One of the great things I discovered with EFCF is generic repositories. This to me was amazing, no longer must I write the same CRUD LINQ for different entities, I could just write one generic base repository and then inherit the generic functionality, whilst adding specific functionality where necessary. This pattern will be covered in a later blog post!

I used EFCF on a variety of projects before attempting this and finally decided to upgrade my final year project to use this for data access to use as an example for this blog post. Below is an example of three POCO’s.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

public class User
{
#region Properties
public int UserId { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
#endregion
#region Collections
public virtual ICollection Problems { get; set; }
#endregion
#region Constructors
public McsUser()
{
Problems = new HashSet()
}
#endregion
}
public class Problem
{
#region Primary Key
public int ProblemId { get; set; }
#endregion
#region Foreign Keys
public int StudentId { get; set; }
public int CommunicationTypeId { get; set; }
public int ProblemTypeId { get; set; }
public int MitigatingCircumstanceLevelId { get; set; }
#endregion
#region Properties
public DateTime? DateTime { get; set; }
public string Outline { get; set; }
public string MitigatingCircumstanceFile { get; set; }
public DateTime? AbsentFrom { get; set; }
public DateTime? AbsentUntil { get; set; }
public DateTime? RequestedFollowUp { get; set; }
public bool iCalAppointment { get; set; }
public bool OutlookAppointment { get; set; }
public virtual Student Student { get; set; }
public virtual CommunicationType CommunicationType { get; set; }
public virtual MitigatingCircumstanceLevel MitigatingCircumstanceLevel { get; set; }
public virtual ProblemType ProblemCategory { get; set; }
#endregion
#region Collections
public virtual ICollection ProblemCommunications { get; set; }
public virtual ICollection AssessmentExtensions { get; set; }
public virtual ICollection Users { get; set; }
#endregion
#region Constructor
public Problem()
{
ProblemCommunications = new List();
AssessmentExtensions = new List();
Users = new HashSet();
}
#endregion
}
public class CommunicationType
{
#region Primary Key
public int CommunicationTypeId { get; set; }
#endregion
#region Properties
public string Name { get; set; }
#endregion
#region Collections
public virtual ICollection Problems { get; set; }
public virtual ICollection ProblemCommunications { get; set; }
#endregion
#region Constructors
public CommunicationType()
{
Problems = new List();
ProblemCommunications = new List();
}
#endregion
}

Below is my Data Context, the string passed to the base class is the name of the connection string which is stored in my web.config file in my MVC project. As you can see I create Database Sets based upon my Object Domain. The on model creating override allows the developer to gain more control over the way EFCF maps Objects to the database. In my example I provide mapping classes which define primary keys, properties (columns) and relationships.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public class McsContext : DbContext
{
public IDbSet Assessments { get; set; }
public IDbSet AssessmentExtensions { get; set; }
public IDbSet CommunicationTypes { get; set; }
public IDbSet McsUsers { get; set; }
public IDbSet MitigatingCircumstanceLevels { get; set; }
public IDbSet Modules { get; set; }
public IDbSet Problems { get; set; }
public IDbSet ProblemCommunications { get; set; }
public IDbSet ProblemTypes { get; set; }
public IDbSet SeminarGroups { get; set; }
public IDbSet Students { get; set; }
public IDbSet StudentStatus { get; set; }
public McsContext(string connStringName) :
base(connStringName)
{
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Conventions.Remove();
modelBuilder.Configurations.Add(new AssessmentMapping());
modelBuilder.Configurations.Add(new AssessmentExtensionMapping());
modelBuilder.Configurations.Add(new CommunicationTypeMapping());
modelBuilder.Configurations.Add(new UserMapping());
modelBuilder.Configurations.Add(new MitigatingCircumstanceLevelMapping());
modelBuilder.Configurations.Add(new ModuleMapping());
modelBuilder.Configurations.Add(new ProblemMapping());
modelBuilder.Configurations.Add(new ProblemCommunicationMapping());
modelBuilder.Configurations.Add(new ProblemTypeMapping());
modelBuilder.Configurations.Add(new SeminarGroupMapping());
modelBuilder.Configurations.Add(new StudentMapping());
modelBuilder.Configurations.Add(new StudentStatusMapping());
}
}

The Configurations contain the mappings between the Entities. The class below shows a Primary Key Mapping, a One to Many Mapping and Property Mappings.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

public class UserMapping : EntityTypeConfiguration
{
public UserMapping()
{
#region Primary Key
this.HasKey(x => x.UserId);
#endregion
#region Foreign Keys
#endregion
#region Properties
this.Property(x => x.UserName);
this.Property(x => x.LoweredUserName);
this.Property(x => x.ApplicationName);
this.Property(x => x.Email);
this.Property(x => x.Comment);
this.Property(x => x.Password);
this.Property(x => x.PasswordQuestion);
this.Property(x => x.PasswordAnswer);
this.Property(x => x.IsApproved);
this.Property(x => x.LastActivityDate);
this.Property(x => x.LastLoginDate);
this.Property(x => x.LastPasswordChangedDate);
this.Property(x => x.CreationDate);
this.Property(x => x.IsOnline);
this.Property(x => x.IsLockedOut);
this.Property(x => x.LastLockedOutDate);
this.Property(x => x.FailedPasswordAttemptCount);
this.Property(x => x.FailedPasswordAttemptWindowStart);
this.Property(x => x.FailedPasswordAnswerAttemptCount);
this.Property(x => x.FailedPasswordAnswerAttemptWindowStart);
this.Property(x => x.MobileAlias);
this.Property(x => x.IsAnonymous);
#endregion
#region Collections
HasMany(x => x.Problems)
.WithMany(y => y.Users)
.Map(m => { m.ToTable("UserProblems"); });
#endregion
ToTable("Users");
}
}

There are many other mappings available in the Configuration files.

One to Many

1
2
3
4

HasRequired(x => x.CommunicationType)
.WithMany(y => y.Problems)
.HasForeignKey(z => z.CommunicationTypeId)
.WillCascadeOnDelete(false);

Inheritance Mapping which you include in the abstract parent entity. Here you define a discriminator column and a unique string value for each child. This enables EFCF to cast the object to the correct child when reading relational data. There are many ways you can store Inheritance Hierarchies such as Table Per Type, Table per Hierarchy etc. Below shows inheritance mapping for four classes which all inherit from a class called Review.

1
2
3
4
5
6

#region Inheritance Mapping
this.Map(x => x.Requires("ReviewType").HasValue("1"))
.Map(x => x.Requires("ReviewType").HasValue("2"))
.Map(x => x.Requires("ReviewType").HasValue("3"))
.Map(x => x.Requires("ReviewType").HasValue("4"));
#endregion

Here’s the resolution for my previous difficulty with Many to Many Mappings. The issue was that I had a scenario where an Event can contain many bands and Bands can be part of many events. However it would be useful to store the start and end time of the Bands appearance at an event, which would be stored in the join table.

1
2
3
4
5
6
7
8
9
10
11
12
13

public class EventConfiguration : EntityTypeConfiguration
{
public EventConfiguration () {
#region Primary Key
this.HasKey(x => x.EventId);
#endregion
#region Foreign Keys
this.HasMany(x => x.Bands)
.WithRequired(z => z.Event)
.HasForeignKey(z => z.EventId);
#endregion
}
}

Band inherited from User in my example (Just an explanation for missing Primary Key / Properties.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public class BandConfiguration : EntityTypeConfiguration
{
public BandConfiguration()
{
#region Primary Key
#endregion
#region Foreign Keys
this.HasMany(x => x.BandEvents)
.WithRequired(y => y.Band)
.HasForeignKey(z => z.BandId);
#endregion
}
}
public class EventBandConfiguration : EntityTypeConfiguration
{
public EventBandConfiguration()
{
#region Primary Key
this.HasKey(x => new { x.EventId, x.BandId });
#endregion
#region Foreign Keys
this.HasRequired(x => x.Event)
.WithMany(y => y.Bands)
.HasForeignKey(z => z.EventId)
.WillCascadeOnDelete(false);
this.HasRequired(x => x.Band)
.WithMany(y => y.BandEvents)
.HasForeignKey(z => z.BandId)
.WillCascadeOnDelete(false);
#endregion
#region Properties
this.Property(x => x.StartDateTime);
this.Property(x => x.EndDateTime);
#endregion
}
}

I believe I then just had two Collections in my POCO’s that just represented the One to Many relationship between the Entity and Join table.

1 2	public virtual ICollection Events { get; set; } public virtual ICollection Bands { get; set; }

For simple joins that do not contain additional attributes EFCF allows you to model this quite easily. Just create Collections in both classes but initialise the collection as a HashSet in the Entities Constructor.

User Entity

1
2
3
4
5
6
7
8
9

#region Collections
public virtual ICollection Problems { get; set; }
#endregion
#region Constructors
public McsUser()
{
Problems = new HashSet();
}
#endregion

Problem Entity

1
2
3
4
5
6
7
8
9

#region Collections
public virtual ICollection Users { get; set; }
#endregion
#region Constructor
public Problem()
{
Users = new HashSet();
}
#endregion

With Configuration Mappings
User:

1
2
3
4
5

#region Collections
HasMany(x => x.Problems)
.WithMany(y => y.Users)
.Map(m => { m.ToTable("UserProblems"); });
#endregion

You can download my sample project here!

jQuery Unlimited Scroll

jonathan — Sat, 07 May 2011 23:44:19 +0000

It’s been a while! I haven’t had much time to blog with beginning a new job (well not so new now) and I have learnt so much more than what I am about to post about. However I just wrote what I think is quite a cool jQuery Plugin which allows for Facebook/Twitter like AJAX loads when a user scrolls to the bottom of the page.

Quite a simple plugin:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

It simply runs an event every time the user scrolls and checks to see whether the user has reached the bottom of the page. If they have we increase the page count, fade in an ajax loading image and then make a request to the server for our JSON.

I’m using ASP MVC so I have a controller method like this:

1
2
3
4
5
6
7
8

#region Json Actions
public JsonResult GetPosts(int? page)
{
IList posts = service.GetAll().Skip(page - 1 ?? 0 * 10).Take(10).ToList();
var slimPosts = (from p in posts select PostDTOFactory.Get(p)).AsEnumerable();
return Json(slimPosts, JsonRequestBehavior.AllowGet);
}
#endregion

This simply retrieve all of the instances of the item we wish to return to the view. In my case a list of Posts. It takes 10 Post items depending on how many posts are already being displayed to the user (standard paging). It them converts my object into a slimmer object, this helped me remove the circular redundancy issues you can have when serializing heavy objects. It also of course allows me to only send the data I actually need to the view, lowering bandwidth costs.

Once the JSON is returned the plugin appends each item returned to the specified element using jQuery Template plugin. The plugin is easily customisable using the settings as below. It allows you to setup where you will be retrieving your JSON from, the element id of your jQuery Template, the element id where you wish to append your returned items and the element id of your AJAX loading icon.

1
2
3
4
5
6
7
8
9
10
11

jQuery Template Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

Download: Source