Anyone who has tried to create tests with Entity Framework (EF) knows that EF is not very unit test friendly. I needed something simple, reusable and unit testable. this generic repository was the result.

The goal of this project was high reusability, ease of implementation and to be unit tests friendly.

There are a lot of Repository Pattern's out there that hide a lot of the underlying functions of your data access layer (in this case LINQ). Well, I really like LINQ to SQL and didn't want to hide any of that. Plus, if you really need encapsulation it should be done in your service layer and not your repository layer.

Some Quick Examples

remember to add "using System.Linq"

IRepository<Log> logs = new Repository<Log>(new MyDataContext());

// use LINQ
var items = from l in logs.All()
            where l.LogType == "Error"
            orderby l.LogId descending
            select l;

// load an item
var item = logs.All().Single(l => l.LogId == 1);

// update an item
item.TimeStamp = DateTime.Now;
logs.Update(item);
logs.Save();

// create an item
item = new Log {
    TimeStamp = DateTime.Now,
    LogType = "Information",
    Message = "This is a new Log!"
};

logs.Add(item);
logs.Save();

// delete an item
logs.Remove(item);

// Eager Loading
items = from l in logs.All("Details")
        select l;

Repository Code

The code is pretty simple, it just looks long because of all the Argument Validation...

public interface IRepository<E>
{
    IQueryable<E> All();
    IQueryable<E> All(string includes);
    void Add(E entity);
    void Remove(E entity);
    void Update(E entity);
    void Save();
}

public class Repository<E> : IRepository<E> where E : EntityObject
{
    protected readonly ObjectContext context;
    protected readonly ObjectSet<E> objectSet;

    public Repository(ObjectContext context)
    {
        #region Argument Validation

        if (context == null)
        {
            throw new ArgumentNullException("context");
        }

        #endregion

        this.context = context;
        this.objectSet = context.CreateObjectSet<E>();
    }

    public virtual IQueryable<E> All()
    {
        return objectSet;
    }

    public virtual IQueryable<E> All(string includes)
    {
        ObjectQuery<E> value = objectSet;
        if (String.IsNullOrEmpty(includes))
        {
            foreach (var includeProperty in includes.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
            {
                value = value.Include(includeProperty.Trim());
            }
        }
        return value;
    }

    public virtual void Add(E entity)
    {
        #region Argument Validation

        if (entity == null)
        {
            throw new ArgumentNullException("entity");
        }

        #endregion

        objectSet.AddObject(entity);
    }

    public virtual void Remove(E entity)
    {
        #region Argument Validation

        if (entity == null)
        {
            throw new ArgumentNullException("entity");
        }

        #endregion

        if (entity.EntityState == EntityState.Detached)
        {
            objectSet.Attach(entity);
        }

        objectSet.DeleteObject(entity);
    }

    public virtual void Update(E entity)
    {
        #region Argument Validation

        if (entity == null)
        {
            throw new ArgumentNullException("entity");
        }

        #endregion

        objectSet.Attach(entity);
        context.ObjectStateManager.ChangeObjectState(entity, EntityState.Modified);
    }

    public void Save()
    {
        context.SaveChanges();
    }
}

Unit Testing

Being able to write Unit Tests is a must and was one of the main goals of creating this repository. With this class, writing unit tests has become much more simple by creating a MemoryRepository.

public class MemoryRepository<E> : IRepository<E> where E : EntityObject
{
    protected readonly List<E> objectSet = new List<E>();

    public virtual IQueryable<E> All()
    {
        return objectSet.AsQueryable();
    }

    public IQueryable<E> All(string includes)
    {
        return All();
    }

    public virtual void Add(E entity)
    {
        objectSet.Add(entity);
    }

    public virtual void Remove(E entity)
    {
        objectSet.Remove(entity);
    }

    public virtual void Update(E entity)
    {
    }

    public void Save()
    {
    }
}

Here's an example test that shows how to populate the MemoryRepository.

[TestMethod]
public void MemoryRepository_can_Add_entities()
{
    // Arrange
    IRepository<Category> value = new MemoryRepository<Category>();
    value.Add(new Category { Category_ID = 1, Category_Name = "Beverages" });
    value.Add(new Category { Category_ID = 2, Category_Name = "Condiments" });
    value.Add(new Category { Category_ID = 3, Category_Name = "Confections" });

    // Act
    int result = value.All().Count();

    // Assert
    Assert.AreEqual(3, result);
}

Be sure to check out Part 2: Repository and Unit of Work for Entity Framework (EF4) for Unit Testing

Why use IIS Express over the Visual Studio Development Server (Cassini)?

I've seen Cassini run inconsistently on different machines, which resulted in the developers having to setup IIS on their local machines which also didn't end up working because they weren't all running the same OS.

Cassini doesn't support the <system.webServer /> node in your config file, which can also give inconsistent results when deployed.

Here are the reasons Scott Guthrie gives:

• It’s lightweight and easy to install (less than 10Mb download and a super quick install)
• It does not require an administrator account to run/debug applications from Visual Studio
• It enables a full web-server feature set – including SSL, URL Rewrite, Media Support, and all other IIS 7.x modules
• It supports and enables the same extensibility model and web.config file settings that IIS 7.x support
• It can be installed side-by-side with the full IIS web server as well as the ASP.NET Development Server (they do not conflict at all)
• It works on Windows XP and higher operating systems – giving you a full IIS 7.x developer feature-set on all OS platforms

more from Guthrie: http://weblogs.asp.net/scottgu/archive/2010/06/28/introducing-iis-express.aspx

Installation

• Be sure you have Microsoft Visual Studio 2010 Service Pack 1 installed.
• Download IIS Exress from Microsoft's Web Gallery.

Enabling IIS Express in your Web Application

Right click on your Web Application and select Use IIS Express...

When you run the Web Application you should now see the IIS Express tray icon.

Extra Credit

By default, IIS Express will bind to the localhost host name.  For most people this is not a big deal, but if you to make this accessible to other computers on the network, you'll have to add a second host name binding.

I run a few Virtual Machines on my box that have older browser version (ie6, etc.) and this is how I gain access with them.

To do this, right click on the tray icon and select Show All Applications and click the application you just created.

After clicking on the Config link (opens the applicationhost.config in Visual Studio) scroll down to the <sites /> section.  You'll see a node that looks like this:

<site name="MvcApplication1" id="2">
    <application path="/" applicationPool="Clr4IntegratedAppPool">
        <virtualDirectory path="/" physicalPath="C:\DEV\MvcApplication1\MvcApplication1" />
    </application>
    <bindings>
      <binding protocol="http" bindingInformation="*:5791:localhost" />
    </bindings>
</site>

Add a binding for your computer's name.  In my case my computer is mobile5.

<site name="MvcApplication1" id="2">
    <application path="/" applicationPool="Clr4IntegratedAppPool">
        <virtualDirectory path="/" physicalPath="C:\DEV\MvcApplication1\MvcApplication1" />
    </application>
    <bindings>
      <binding protocol="http" bindingInformation="*:5791:localhost" />
      <binding protocol="http" bindingInformation="*:5791:mobile5" />
    </bindings>
</site>

Optional*: Open your project's properties and set your Start URL to http://mobile5:5791.  Check the box "Override application root URL" and insert the same value http://mobile5:5791/

(if IIS Express is currently running you will have to stop it for the changes to take effect)

Final Thoughts

That should be it.  You should now be running your Web Application under IIS Express.  Other PCs or VMs should be able to view your projects via the additional binding.

* Skip the optional step if the project is used by multiple developers or opened on multiple machines.

** Additional bindings may require you to run Visual Studio as an Administrator or add entries into your host files.

Disclaimer: This article assumes you already know the following: C#, WF4 and Extension Methods.

Lately I have been reading a bunch about Data, Context and Interaction (DCI) and a lot of my current project have involved using Windows Workflow Foundation (WF4).  Recently I've come to the realizaion that a WF4 Activity can also be the perfect DCI context because both are basically use cases.

I've taken some sample code written by Christian Horsdal about DCI in C# and applied to to a Workflow.  He's has some very good posts about DCI and C#, I'd recommend checking them out if you want to learn more.

The Data

First we'll have a look at the data models we'll be using.

We've got our base Account class and our derived classes CheckingAccount and SavingsAccount.

public abstract class Account
{
    public double Balance { get; protected set; }

    public void Withdraw(double amount)
    {
        Balance -= amount;
    }

    public void Deposit(double amount)
    {
        Balance += amount;
    }

    public void Log(string message)
    {
        Console.WriteLine("Log: {0}", message);
    }
}

public class CheckingAccount
    : Account, TransferMoneySource, TransferMoneySink
{
    public CheckingAccount()
    {
        Balance = 1000;
    }

    public override string ToString()
    {
        return "Balance " + Balance;
    }
}

public class SavingsAccount
    : Account, TransferMoneySource, TransferMoneySink
{
    public SavingsAccount()
    {
        Balance = 1000;
    }

    public override string ToString()
    {
        return "Balance " + Balance;
    }
}

The Interaction

In our Data Models, you'll notice there's a TransferMoneySource and TransferMoneySink on each of our derived account classes. Those are the Roles these accounts can play, they can be both the Source or Sink when transfering money.

The Roles are defined as Interfaces and provide just the minimum amount of data to perform that Interaction.

In C# one way of providing the DCI Interaction is through the use of extension methods (eg: the TransferTo method below).

public interface TransferMoneySink
{
    void Deposit(double amount);
    void Log(string message);
}

public interface TransferMoneySource
{
    double Balance { get; }
    void Withdraw(double amount);
    void Log(string message);
}

public static class TransferMoneySourceTrait
{
    public static void TransferTo(this TransferMoneySource self, TransferMoneySink recipient, double amount)
    {
        if (self.Balance < 0)
        {
            throw new ApplicationException("insufficient funds");
        }

        self.Withdraw(amount);
        self.Log("Withdrawing " + amount);
        recipient.Deposit(amount);
        recipient.Log("Depositing " + amount);
    }
}

The Context

For the Transfer Money use case, we're going to Withdraw money from one account and Deposit it into another using the TransferTo extension method we created above. This use case requires three things: the Source, the Sink and the Amount.

Written as a WF4 Activity, it will look like this...

public sealed class TransferMoneyActivity : CodeActivity
{
    [RequiredArgument]
    public InArgument<TransferMoneySource> Source { get; set; }

    [RequiredArgument]
    public InArgument<TransferMoneySink> Sink { get; set; }

    [RequiredArgument]
    public InArgument<double> Amount { get; set; }

    protected override void Execute(CodeActivityContext context)
    {
        var source = Source.Get(context);
        var sink = Sink.Get(context);
        var amount = Amount.Get(context);

        source.TransferTo(sink, amount);
    }
}

Executing the Activity / Context (use case)

Transfering $100 from the CheckingAccount to SavingsAccount can be as simple as this.

var savingsAccount = new SavingsAccount();
var checkingAccount = new CheckingAccount();

var arguments = new Dictionary<string, object> {
    { "Source", checkingAccount },
    { "Sink", savingsAccount },
    { "Amount", 100 }
};

WorkflowInvoker.Invoke(new DemoActivity(), arguments);

And now that our Context is a standard WF4 Activity, we can easily incorporate it into our larger Workflows.

Download the sample project here