When working with Entity Framework – Code First model approach, developer creates POCO entities for Database tables. The benefit of using Code First model is to have POCO entity for each table that can be used as either WCF Data Contracts or you can apply your own custom attributes to handle Security, Logging, etc. and there is no mapping needed as we used to do in Entity Framework (Model First) approach if the application architecture is n-tier based.

Considering the Data Access layer, we will implement a repository pattern that encapsulates the persistence logic in a separate class. This class will be responsible to perform database operations. Let’s suppose the application is based on n-tier architecture and having 3 tiers namely Presentation, Business and Data Access. Common library contains all our POCO entities that will be used by all the layers.

Presentation Layer: Contains Views, Forms

Business Layer: Managers that handle logic functionality

Data Access Layer: Contains Repository class that handles CRUD operations

Common Library: Contain POCO entities.

We will implement an interface named “IRepository” that defines the signature of all the appropriate generic methods needed to perform CRUD operation and then implement the Repository class that defines the actual implementation of each method. We can also instantiate Repository object using Dependency Injection or apply Factory pattern.

Code Snippet: IRepository

public
interface
IRepository : IDisposable

{

///
<summary>

/// Gets all objects from database

///
</summary>

///
<returns></returns>

IQueryable<T> All<T>() where T : class;

///
<summary>

/// Gets objects from database by filter.

///
</summary>

///
<param name=”predicate”>Specified a filter</param>

///
<returns></returns>

IQueryable<T> Filter<T>(Expression<Func<T, bool>> predicate) where T : class;

///
<summary>

/// Gets objects from database with filting and paging.

///
</summary>

///
<typeparam name=”Key”>

///
<param name=”filter”>Specified a filter</param>

///
<param name=”total”>Returns the total records count of the filter.</param>

///
<param name=”index”>Specified the page index.</param>

///
<param name=”size”>Specified the page size</param>

///
<returns></returns>

IQueryable<T> Filter<T>(Expression<Func<T, bool>> filter, out
int total, int index = 0, int size = 50) where T : class;

///
<summary>

/// Gets the object(s) is exists in database by specified filter.

///
</summary>

///
<param name=”predicate”>Specified the filter expression</param>

///
<returns></returns>

bool Contains<T>(Expression<Func<T, bool>> predicate) where T : class;

///
<summary>

/// Find object by keys.

///
</summary>

///
<param name=”keys”>Specified the search keys.</param>

///
<returns></returns>

T Find<T>(params
object[] keys) where T : class;

///
<summary>

/// Find object by specified expression.

///
</summary>

///
<param name=”predicate”></param>

///
<returns></returns>

T Find<T>(Expression<Func<T, bool>> predicate) where T : class;

///
<summary>

/// Create a new object to database.

///
</summary>

///
<param name=”t”>Specified a new object to create.</param>

///
<returns></returns>

T Create<T>(T t) where T : class;

///
<summary>

/// Delete the object from database.

///
</summary>

///
<param name=”t”>Specified a existing object to delete.</param>

int Delete<T>(T t) where T : class;

///
<summary>

/// Delete objects from database by specified filter expression.

///
</summary>

///
<param name=”predicate”></param>

///
<returns></returns>

int Delete<T>(Expression<Func<T, bool>> predicate) where T : class;

///
<summary>

/// Update object changes and save to database.

///
</summary>

///
<param name=”t”>Specified the object to save.</param>

///
<returns></returns>

int Update<T>(T t) where T : class;

///
<summary>

/// Select Single Item by specified expression.

///
</summary>

///
<typeparam name=”T”></typeparam>

///
<param name=”expression”></param>

///
<returns></returns>

T Single<T>(Expression<Func<T, bool>> expression) where T : class;

void SaveChanges();

void ExecuteProcedure(String procedureCommand, params
SqlParameter[] sqlParams);

}

Code Snippet: Repository

public
class
Repository : IRepository

{

DbContext Context;

public Repository()

{

Context = new
DBContext();

}

public Repository(DBContext context)

{

Context = context;

}

public
void CommitChanges()

{

 Context.SaveChanges();

}

public T Single<T>(Expression<Func<T, bool>> expression) where T : class

{

return All().FirstOrDefault(expression);

}

public
IQueryable<T> All<T>() where T : class

{

return Context.Set().AsQueryable();

}

public
virtual
IQueryable<T> Filter<T>(Expression<Func<T, bool>> predicate) where T : class

{

return Context.Set<T>().Where<T>(predicate).AsQueryable<T>();

}

public
virtual
IQueryable<T> Filter<T>(Expression<Func<T, bool>> filter, out
int total, int index = 0, int size = 50) where T : class

{

int skipCount = index * size;

var _resetSet = filter != null ? Context.Set().Where(filter).AsQueryable() : Context.Set().AsQueryable();

 _resetSet = skipCount == 0 ? _resetSet.Take(size) : _resetSet.Skip(skipCount).Take(size);

total = _resetSet.Count();

return _resetSet.AsQueryable();

}

public
virtual T Create(T TObject) where T : class

{

var newEntry = Context.Set().Add(TObject);

Context.SaveChanges();

return newEntry;

}

public
virtual
int Delete(T TObject) where T : class

{

 Context.Set().Remove(TObject);

return Context.SaveChanges();

}

public
virtual
int Update(T TObject) where T : class

{

try

{

var entry = Context.Entry(TObject);

 Context.Set().Attach(TObject);

entry.State = EntityState.Modified;

return Context.SaveChanges();

}

catch (OptimisticConcurrencyException ex)

{

throw ex;

}

}

public
virtual
int Delete<T>(Expression<Func<T, bool>> predicate) where T : class

{

var objects = Filter<T>(predicate);

foreach (var obj in objects)

Context.Set<T>().Remove(obj);

return Context.SaveChanges();

}

public
bool Contains<T>(Expression<Func<T, bool>> predicate) where T : class

{

return Context.Set<T>().Count<T>(predicate) > 0;

}

public
virtual T Find<T>(params
object[] keys) where T : class

{

return (T)Context.Set<T>().Find(keys);

}

public
virtual T Find<T>(Expression<Func<T, bool>> predicate) where T : class

{

return Context.Set<T>().FirstOrDefault<T>(predicate);

}

public
virtual
void ExecuteProcedure(String procedureCommand, params
SqlParameter[] sqlParams){

 Context.Database.ExecuteSqlCommand(procedureCommand, sqlParams);

}

public
virtual
void SaveChanges()

{

Context.SaveChanges();

}

public
void Dispose()

{

if (Context != null)

Context.Dispose();

}

}

The benefit of using Repository pattern is that all the database operations will be managed centrally and in future if you want to change the underlying database connector you can add another Repository class and defines its own implementation or change the existing one.