I will illustrate the usage of the following frameworks:<\/p>\n
- \n
- MvcContrib<\/a> bringing useful extension methods and strongly typed helpers to ASP.NET MVC<\/li>\n
- AutoMapper<\/a> enabling easy mapping between the domain and the view models<\/li>\n
- FluentValidation<\/a> – a small validation library for .NET that uses a fluent interface and lambda expressions for building validation rules for your business objects<\/li>\n
- NHibernate<\/a> \u2013 a popular ORM in the .NET world<\/li>\n
- FluentNHibernate<\/a> – a statically compiled alternative to NHibernate’s standard hbm xml mapping<\/li>\n
- Spring.NET<\/a> \u2013 object container and dependency Injection framework for .NET<\/li>\n
- Rhino.Mocks<\/a> – A dynamic mock object framework for the .Net platform. It’s purpose is to ease testing by allowing the developer to create mock implementations of custom objects and verify the interactions using unit testing<\/li>\n<\/ul>\n
<\/p>\n
Armed with this arsenal of frameworks let\u2019s start exploring the solution structure. I\u2019ve opted for 2 projects solution but in many real world applications more levels of abstraction could be brought to the business layer. Personally I favor to have less big assemblies rather than many small assemblies into the solution. Fewer the assemblies, faster the load time and faster the IDE. In this case particular attention should be brought to bring proper separation of concerns inside the same assembly<\/p>\n
<\/p>\n
![\"ASP.Net](\"http:\/\/dev.bratched.fr\/fr\/wp-content\/uploads\/sites\/2\/importedmedia\/blogmedia-project-structure-thumb-png.png\" "\\"ASP.Net")
<\/a><\/p>\n<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
The domain consists of a single User class and a repository interface defining the different operations on this model:<\/p>\n
![\"ASP.Net](\"http:\/\/dev.bratched.fr\/fr\/wp-content\/uploads\/sites\/2\/importedmedia\/blogmedia-domain-thumb-png.png\" "\\"ASP.Net")
<\/a><\/p>\n<\/p>\n
Mapping<\/h1>\n
The next step is to define the mapping between our domain and a relational model expressed in a fluent manner:<\/p>\n
\npublic class UserMap : ClassMap<User>\n{\n public UserMap()\n {\n Table(\"users\");\n Id(x => x.Id, \"usr_id\");\n Map(x => x.FirstName, \"usr_firstname\");\n Map(x => x.LastName, \"usr_lastname\");\n Map(x => x.Age, \"usr_age\");\n }\n}\n<\/pre>\n<\/div>\n<\/p>\n
And here\u2019s the implementation of the repository:<\/p>\n
\npublic class SqlUsersRepository : HibernateDaoSupport, IUsersRepository\n{\n public IEnumerable<User> GetUsers()\n {\n return HibernateTemplate.LoadAll<User>();\n }\n\n public User Get(int id)\n {\n return HibernateTemplate.Get<User>(id);\n }\n\n public void Delete(int id)\n {\n HibernateTemplate.Delete(new User { Id = id });\n }\n\n public int Save(User user)\n {\n return (int)HibernateTemplate.Save(user);\n }\n\n public void Update(User user)\n {\n HibernateTemplate.Update(user);\n }\n}<\/pre>\n<\/div>\n<\/p>\n
HibernateDaoSupport<\/em> is a base class defined by the Spring Framework managing SQL transactions and NHibernate session.<\/p>\n
Once we have implemented the data access layer we could move on to the web part. The application consists of a single RESTful UsersController allowing the standard CRUD operations with our users model. As all our views are strongly typed we shall define a view model for each view and a mapping between the domain model and this view model. In our simple case the view model will simply have the same structure as the domain model but in real world scenarios it will be a projection of the domain model for a particular view.<\/p>\n
\n[Validator(typeof(UserViewModelValidator))]\npublic class UserViewModel\n{\n public int Id { get; set; }\n public string FirstName { get; set; }\n public string LastName { get; set; }\n public int? Age { get; set; }\n}\n<\/pre>\n<\/div>\nAnd the respective validator:<\/p>\n
\npublic class UserViewModelValidator : AbstractValidator<UserViewModel>\n{\n public UserViewModelValidator()\n {\n RuleFor(x => x.FirstName)\n .NotEmpty()\n .WithMessage(\"First name is required\")\n .DisplayName(\"First name *\");\n\n RuleFor(x => x.LastName)\n .NotEmpty()\n .WithMessage(\"Last name is required\")\n .DisplayName(\"Last name *\");\n }\n}\n<\/pre>\n<\/div>\nAnd mapper between the domain and view model:<\/p>\n
<\/p>\n
\npublic class UserMapper : IMapper\n{\n static UserMapper()\n {\n Mapper.CreateMap<User, UserViewModel>();\n Mapper.CreateMap<UserViewModel, User>();\n }\n\n public object Map(object source, Type sourceType, Type destinationType)\n {\n return Mapper.Map(source, sourceType, destinationType);\n }\n}\n<\/pre>\n<\/div>\n<\/p>\n
This bidirectional mapper will be used by our RESTful controller:<\/p>\n
\npublic class UsersController : BaseController<IUsersRepository>\n{\n public UsersController(IUsersRepository repository, IMapper userMapper) \n : base(repository, userMapper)\n { }\n\n [AutoMap(typeof(IEnumerable<User>), typeof(IEnumerable<UserViewModel>))]\n public ActionResult Index()\n {\n \/\/ return all users\n var users = Repository.GetUsers();\n return View(users);\n\n }\n\n public ActionResult New()\n {\n \/\/ return an HTML form for describing a new user\n return View();\n }\n\n [HttpPost]\n [AutoMap(typeof(User), typeof(UserViewModel))]\n public ActionResult Create(UserViewModel userView)\n {\n \/\/ create a new user\n if (!ModelState.IsValid)\n {\n return View(\"New\", userView);\n }\n var user = (User)ModelMapper.Map(userView, typeof(UserViewModel), typeof(User));\n Repository.Save(user);\n return RedirectToAction(\"Index\", \"Users\");\n }\n\n [AutoMap(typeof(User), typeof(UserViewModel))]\n public ActionResult Show(int id)\n {\n \/\/ find and return a specific user\n var user = Repository.Get(id);\n return View(user);\n }\n\n [AutoMap(typeof(User), typeof(UserViewModel))]\n public ActionResult Edit(int id)\n {\n \/\/ return an HTML form for editing a specific user\n var user = Repository.Get(id);\n return View(user);\n }\n\n [HttpPut]\n public ActionResult Update(UserViewModel userView)\n {\n \/\/ find and update a specific user\n if (!ModelState.IsValid)\n {\n return View(\"Edit\", userView);\n }\n var user = (User)ModelMapper.Map(userView, typeof(UserViewModel), typeof(User));\n Repository.Update(user);\n return RedirectToAction(\"Index\", \"Users\");\n }\n\n [HttpDelete]\n public ActionResult Destroy(int id)\n {\n \/\/ delete a specific user\n Repository.Delete(id);\n return RedirectToAction(\"Index\", \"Users\");\n }\n}<\/pre>\n<\/div>\n<\/p>\n
Notice the AutoMapAttribute<\/em>. This is a custom attribute allowing us to automatically convert the domain model retrieved by the repository to a view model and present it to the view:<\/p>\n
\n[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]\npublic class AutoMapAttribute : ActionFilterAttribute\n{\n public Type SourceType { get; private set; }\n public Type DestType { get; private set; }\n\n public AutoMapAttribute(Type sourceType, Type destType)\n {\n SourceType = sourceType;\n DestType = destType;\n }\n\n public override void OnActionExecuted(ActionExecutedContext filterContext)\n {\n base.OnActionExecuted(filterContext);\n var controller = filterContext.Controller as IModelMapperController;\n if (controller == null)\n {\n return;\n }\n var model = filterContext.Controller.ViewData.Model;\n if (model != null && SourceType.IsAssignableFrom(model.GetType()))\n {\n var viewModel = controller.ModelMapper.Map(model, SourceType, DestType);\n filterContext.Controller.ViewData.Model = viewModel;\n }\n }\n}<\/pre>\n<\/div>\nThe OnActionExecuted<\/a> method will be called after each action method has finished executing and it will use the model passed to the view and convert it to the appropriate view model. It simply substitutes the ViewData.Model<\/em> property with the appropriate view model to finally pass it to the view for rendering.<\/p>\n
<\/p>\n
The controller follows the standard RESTful conventions for naming the action and the HTTP verbs:<\/p>\n
<\/p>\n
- AutoMapper<\/a> enabling easy mapping between the domain and the view models<\/li>\n