N-layer architecture schema

• My source code for this post: github repository.

In two recent posts I took about entity framework 4.1/2 features and then create a domain layer for using their layers in UI layer.
In this post I will talk about an independent UI (web) layer. So, for this independency in web layer I used a dependency injection tool for using direct service interfaces in all controllers. According to this link with some benchmarks seems structuremap is better than other dependency injection third-parties tools. So I used structuremap.
Also, you can create a utility project and import all common your extension classes and your general html helpers for using to this project or other projects (may be as a template project).for do this, you should add system.web and system.web.mvc references to utility project.

Note: Maybe you want using utility library to all your enterprise applications, for this case you can make a local nuget package from this utility project, and then add utility package to all projects very fast. I’ll talk about “How to organized local nuget packages” in the next posts, but now you can see hanselman post about ‘how to create nuget packages’ or some docs in official nuget site. or visit this weblog
Anyway, come back to our target! I want create a sample for using domain layer in MVC project, so I choose membership subject for my sample. I wrote a customized membership. For do that, we should dirty some Domain codes.

You can assume I want create a form-Authentication based on .NET and using native classes for authentication with cookies in .NET but In this sample I want show to you that how to using native .net framework for making session based authentication.
In above figure you see some new classes under “Site” namespace. Please for more information about project check out project from Github.
There is a Controller class in Site namespace that I called AuthenticationController.
This base class for all controllers can do authentication and authorization for all users with difference roles.

using System.Threading;
using System.Web.Mvc;

namespace Arash.Membership.Site
{
    public class AuthenticationController : Controller
    {
        protected override void OnAuthorization(AuthorizationContext filterContext)
        {
            if (SessionPersister.SitePrincipal != null)
            {
                Thread.CurrentPrincipal = SessionPersister.SitePrincipal;
                filterContext.HttpContext.User = SessionPersister.SitePrincipal;
            }

            base.OnAuthorization(filterContext);
        }
    }
}

Other classes such as SiteIndentity or SitePrincipal are only an implement of some native .NET interfaces.
And Now Web layer:
- Install structuremap:
I added this third-party with execute command in packet manager:

PM> Install-Package structuremap

For using authentication you can create a derived controller form Authentication controller.
Conclusions:
After recent three posts we could create a new organized model for creating n-layer applications. And then implement a session based authentication model for sample, I hope you use this model and say me disadvantages or advantages.

You can download this sample form github repository.

Recently i heard about repository pattern! So I’m implementing this in a new project and then i’ll complete the domain layer:

Before implementing the repository pattern i need an interface to access the DataAccess layer, So i create IDbContext interface in the Infrastructure library project:

public interface IDbContext

    {
        IDbSet Set() where T : class;

        Database Db { get; }

        int SaveChanges();
    }

Now i add a Repository pattern to the project:

First i use an interface repository in Infrastructure project:

public interface IRepository where T : class
{
        ///
 /// Create New Instance /// 

 T NewEntityInstance(); ///
 /// Inserts an item /// 

 void Add(T item); ///
 /// Deletes an item /// 

 void Remove(T item); ///
 /// Get an item matching to prediate /// 

 T Get(Funcpredicate); ///
 /// Get Count of items matching to predicate /// 

 int GetCount(Funcpredicate); ///
 /// Get IEnumerable object matching to predicate /// 

 IEnumerableGetAll(Funcpredicate); ///
 /// Get IEnumerable object matching to predicate,start index and count /// 

 IEnumerableGetAll(Funcpredicate, int start, int count); ///
 /// Saves the pending changes back into the DataContext. /// 

 void Save();
}

And then put it in DataAccess project:

    public class Repository : IRepository where T : class
    {
        protected IDbContext _Context;
        protected IDbSet _DbSet;

        public Repository(IDbContext context)
        {
            _Context = context;
            _DbSet = _Context.Set();
        }

        public T NewEntityInstance()
        {
            return _DbSet.Create();
        }

        public void Add(T entity)
        {
            _DbSet.Add(entity);
        }

        public virtual IQueryable GetAll()
        {
            return _DbSet.AsQueryable();
        }

        public void Remove(T entity)
        {
            _DbSet.Remove(entity);
        }

        public T Get(Func predicate)
        {
            return _DbSet.FirstOrDefault(predicate);
        }

        public int GetCount(Func predicate)
        {
            return _DbSet.Count(predicate);
        }

        public IEnumerable GetAll(Func predicate)
        {
            return _DbSet.Where(predicate);
        }

        public IEnumerable GetAll(Func predicate, int start, int count)
        {
            return _DbSet.Where(predicate).Skip(start).Take(count);
        }

        public void Save()
        {
            try
            {
                _Context.SaveChanges();
            }
            catch (DbEntityValidationException e)
            {
                var s = e.EntityValidationErrors.ToList();
                throw;
            }
        }

        public IEnumerable GetQuery(string queryString, Func predicate = null) where K : class
        {
            if (predicate != null)
                return _Context.Db.SqlQuery(queryString).Where(predicate);
            return _Context.Db.SqlQuery(queryString);

        }
    }

Good, Service classes are ready to be used in Controllers and action methods.

How to create a service:

for example i wrote a simple service named MemberManager:

using System;
using System.Collections.Generic;
using Arash.Membership.Model;

namespace Arash.Core
{
    public interface IMemberManager
    {
        Member MakeInstance();

        void Add(Member entity);

        void Edit(Member entity);

        void Remove(Member entity);

        int GetCount(Func predicate = null);

        Member Get(Func predicate = null);

        IEnumerable GetAll(Func predicate = null, int start = 0, int count = 6);

        Member Authenticate(string username, string password);
    }
}

implemented Member service class:

using System;
using System.Collections.Generic;
using Arash.Membership.Model;
using Arash.Utility.Common;
using Paradiso.Infrastructure.Data;
using Arash.Infrastructure.Data;

namespace Arash.Core.Manager
{
    public class MemberManager : IMemberManager
    {
        private IRepository _repository;

        public MemberManager(IRepository repository)
        {
            _repository = repository;
        }

        public Member MakeInstance()
        {
            return _repository.NewEntityInstance();
        }

        public void Add(Member entity)
        {
            _repository.Add(entity);
            _repository.Save();
        }

        public void Edit(Member entity)
        {
            _repository.Save();
        }

        public void Remove(Member entity)
        {
            _repository.Remove(entity);
            _repository.Save();
        }

        public int GetCount(Func predicate = null)
        {
            return predicate == null
                ? _repository.GetCount(p => true)
                : _repository.GetCount(predicate);
        }

        public Member Get(Func predicate = null)
        {
            return predicate == null
                ? _repository.Get(p => true)
                : _repository.Get(predicate);
        }

        public IEnumerable GetAll(Func predicate = null, int start = 0, int count = 6)
        {
            return predicate == null
                 ? _repository.GetAll(p => true)
                 : start == 0
                     ? _repository.GetAll(predicate)
                     : _repository.GetAll(predicate, start, count);
        }

        public Member Authenticate(string username, string password)
        {
            var entity = _repository.Get(p => p.Username == username);

            if (entity == null)
                return null;

            var passwordHash = PasswordGenerator.GetHashPassword(password);

            if (!string.Equals(passwordHash, password))
                return null;

            return entity;
        }
    }
}

Conclusion:

We learned how to implement some layers in n-layer architecture. Ofcourse you can download source codes of posts part1 and 2 from github

So today I want speak about entity framework 4.1/2.

In the EF 4.1/2 we can design a project with code first approach and make a dynamic SQL database.

Why don’t used Entity framework features?

• Without create a database project and writing dummy query and insert data to DB for test we could create a DbContextInitializer class for create dummy objects for creating Database and insert all objects to Database.

• We could separate all entities form each others.In many project we don’t need come all entities populate in one library or I want make modular projects. See my sample project models:
  

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace Arash.Core.Model
{
    [Table("EntityBase")]
    public abstract class EntityBase
    {
        // primitive
        [Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public int EntityId
        {
            get;
            set;
        }

        [ForeignKey("EntityType")]
        public int EntityTypeId { get; set; }

        // navigation

        [ForeignKey("EntityTypeId")]
        public EntityType EntityType
        {
            get;
            set;
        }

        public EntityTypes EntityTypes
        {
            get
            {
                return (EntityTypes)EntityType.Id;
            }
            set
            {
                EntityTypeId = (int)EntityTypes;
            }
        }

        public virtual IEnumerable Tages { get; set; }
    }
}
}

using System.Data.Entity;
using Arash.Core.Model;
using Arash.Membership.Model;
using Arash.Restaurant.Model;
using Paradiso.Infrastructure.Data;

namespace Arash.DataAccess
{
    public class ArashDbContext : DbContext, IDbContext
    {
        public ArashDbContext() : base("arashConnectionString") { }

        public DbSet Members { get; set; }
        public DbSet Roles { get; set; }
        public DbSet Users { get; set; }
        public DbSet Jobs { get; set; }
        public DbSet EntityBases { get; set; }
        public DbSet EntityType { get; set; }
        public DbSet Tages { get; set; }
        public DbSet TagEntities { get; set; }
        public DbSet Coffeeshops { get; set; }

        public new IDbSet Set() where T : class
        {
            return base.Set();
        }

        public Database Query
        {
            get { return this.Database; }
        }

        public IDbSet GetDbSet() where T : class
        {
            return null;
        }

        public Database Db
        {
            get { return this.Database; }
        }
    }
}

sing System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.Validation;
using System.Linq;
using Arash.Core.Model;
using Arash.DataAccess;

namespace Arash.DataAccess
{
    public class ArashDbContextInitializer : DropCreateDatabaseAlways
    {
        protected override void Seed(ArashDbContext context)
        {
            #region entity type
            new List
            {
                new EntityType {
                    Name = "Coffeeshop"
                },
                new EntityType {
                    Name = "bar"
                }
            }.ForEach(m => context.EntityType.Add(m));
            #endregion

            try
            {
                context.SaveChanges();
            }
            catch (DbEntityValidationException e)
            {
                var ex = e.EntityValidationErrors.ToList();
            }

            base.Seed(context);
        }
    }
}

void main(){
printf("hello world.");
}