A Light-Weight MVC Route Debugging App

by Jason 9. December 2009 10:26

I have a huge MVC project that I am working with that has a pretty complex routing schema. Debugging routes gets pretty hairy, so I was delighted to find the RouteDebug assembly that Phil Haack put together. It helped me immensely, but my project takes too long to compile for quick route testing. 

I needed a quick way of creating routes and testing the route values, so I created a super-light-weight small website to use his assembly with nothing else.  You can put your route creation code right into the Global.asax and instantly get the results. I found this super useful and I hope you do too.

 

RouteDebug-Web.zip (12.19 kb)

Tags: , ,

Expression-Based URLs in MVC - Using a Specific Route with LinkBuilder

by Jason 8. December 2009 15:29

In the MVC Future Assembly there lives a super handy class called "LinkBuilder". This class takes an expression and builds a URL using your configured routes.

Creating an extension method in your own project to use this class is pretty straight forward:

public static string Action<TController>(this UrlHelper helper, Expression<Action<TController>> action)

    where TController : Controller

{

    return Microsoft.Web.Mvc.LinkBuilder.BuildUrlFromExpression(helper.RequestContext, helper.RouteCollection, action);

}

You can also use this library to create your own "ActionLink" extensions too. BUT, this isn't why I wrote this article.

I wanted to extend this method to specify an EXACT route to use, as I had a special route to format the URLs and the above method uses the first route it finds that could work - usually the default route.

After struggling for hours trying to parse the expression myself (UGH!), a simple solution presented itself:

public static string Action<TController>(this UrlHelper helper, Expression<Action<TController>> action, string routeName)

    where TController : Controller

{

    var routeCollection = helper.RouteCollection;

 

    // Check to ensure this route exists first. If not, don't filter the routes.

    if (helper.RouteCollection[routeName] != null)
         routeCollection  = new RouteCollection { helper.RouteCollection[routeName] };

 

    return Microsoft.Web.Mvc.LinkBuilder.BuildUrlFromExpression(helper.RequestContext, routeCollection, action);

}

This method filters the RouteCollection down to the exact route you are want to use and passes the filtered collection to the LinkBuilder... ahhh, routing-bliss.

Now you can use it in your views like this:

<%= Url.Action<CredentialsController>(c => c.Edit(credID), "CredentialActions") %>

 

 

Tags: , ,

A Generic Repository for LinqToSql

by Jason 5. November 2009 13:01

In my last article, I showed you a way of creating an interface for the LinqToSql DataContext so that you can mock the actual implementation for unit testing. Well, there is another benifit to creating such an interface. The interface we created, uses LinqToSql's underying generic methods. Using this, we can create a completely generic repository class, to handle all data transactions from our data-layer.

I won't get into the Repository Pattern or Domain Driven Design, because there are too many people out there, WAY smarter than me discussing it in full. I use this pattern mainly for convenience in testing and reducing code, but it is worth reading up on -- it is some great stuff!

First off, there are literally a THOUSAND articles out there talking about the Repository Pattern and quite a few articles discussing implementing this with the LinqToSql DataContext. None of them were quite what I needed, so I present to you, my version with ideas borrowed from this article and this one (both of these concepts are awesome, however they lacked the IDataContext piece so that it can be unit tested.

IDataContext

First, let's assume that you have already followed my last article, and your DataContext implements IDataContext.

public interface IDataContext : IDisposable

{

    IQueryable<TEntity> GetQueryable<TEntity>() where TEntity : class;

    ITable GetEditable<TEntity>() where TEntity : class;

    void Insert<TEntity>(TEntity instance) where TEntity : class;

    void InsertAll<TEntity>(IEnumerable<TEntity> instances) where TEntity : class;

    void Delete<TEntity>(TEntity instance) where TEntity : class;

    void DeleteAll<TEntity>(IEnumerable<TEntity> instances) where TEntity : class;

    void SubmitChanges();

    int ExecuteCommand(string command, params object[] parameters);

    DbConnection Connection { get; }

}

Implemented in your DataContext

partial class SampleDataContext : IDataContext

{

    public virtual IQueryable<TEntity> GetQueryable<TEntity>() where TEntity : class

    {

        return this.GetTable<TEntity>();

    }

 

    public virtual ITable GetEditable<TEntity>() where TEntity : class

    {

        return this.GetTable<TEntity>();

    }

 

    public void Insert<TEntity>(TEntity instance) where TEntity : class

    {

        this.GetTable<TEntity>().InsertOnSubmit(instance);

    }

 

    public void InsertAll<TEntity>(IEnumerable<TEntity> instances) where TEntity : class

    {

        this.GetTable<TEntity>().InsertAllOnSubmit(instances);

    }

 

    public void Delete<TEntity>(TEntity instance) where TEntity : class

    {

        this.GetTable<TEntity>().DeleteOnSubmit(instance);

    }

 

    public void DeleteAll<TEntity>(IEnumerable<TEntity> instances) where TEntity : class

    {

        this.GetTable<TEntity>().DeleteAllOnSubmit(instances);

    }

}

IDataRepository

Once implemented, let's create our interface for the IDataRepository. We will need the basic data operations: List, GetAddDelete and SubmitChanges.

public interface IDataRepository<T>

        where T : class

{

    IQueryable<T> List();

    T Get(int id);

    T Get(Expression<Func<T, bool>> selector);

    void Add(T instance);

    void Delete(T instance);

    void SubmitChanges();

}

DataRepository<T>

Ah, moving on to the actual implementation... Use IDataContext to implement the repository methods.

public class DataRepository<T> : IDataRepository<T>

        where T : class

{

    private readonly IDataContext _DataContext;

 

    public DataRepository(IDataContext dataContext)

    {

        _DataContext = dataContext;

    }

 

    public IQueryable<T> List()

    {

        return _DataContext.GetQueryable<T>();

    }

 

    public T Get(int id)

    {

        var itemParameter = Expression.Parameter(typeof(T), "item");

 

        var whereExpression = Expression.Lambda<Func<T, bool>>

            (

            Expression.Equal(

                Expression.Property(

                    itemParameter,

                    typeof(T).GetPrimaryKey().Name

                    ),

                Expression.Constant(id)

                ),

            new[] { itemParameter }

            );

 

        return _DataContext.GetQueryable<T>().SingleOrDefault(whereExpression);

    }

 

    public T Get(Expression<Func<T, bool>> selector)

    {

        return _DataContext.GetQueryable<T>().SingleOrDefault(selector);

    }

 

    public void Add(T instance)

    {

        _DataContext.GetEditable<T>().InsertOnSubmit(instance);

    }

 

    public void Delete(T instance)

    {

        _DataContext.GetEditable<T>().DeleteOnSubmit(instance);

    }

 

    public void SubmitChanges()

    {

        _DataContext.SubmitChanges();

    }

}

This class uses Dependency Injection and accesses the DataContext as IDataContext. This allows us to create unit tests for this class with a mocked data-context.

There are two Get methods, both of which pass a Where expression down to the Linq extensions. The first attempts to build an expression manually. This is assuming that you use int as your IDs. If you don't you can always update the code to fit your needs. GetPrimaryKey() is an extension method written by the genius, Mike Hadlow over here. It's awesome, and I included it down below.

Both return a single instance from the DataContext, but the Get(Expression<Func<T,bool>> selector) function allows a more complex lookup (for complex identities or whatever). It's passed as an expression, just like the "Where()" function, in the Linq extensions.

Sample Usage

So what does this buy us? Well, with this simple generic class we suddenly have a full, strongly-typed repository layer for each object in the DataContext.

Check it out:

public class Controller

{

    readonly IDataRepository<User> _UserRepository;

    readonly IDataRepository<Car> _CarRepository;

 

    // Go ahead and use Dependency Injection -- you know you wanna.

    public Controller(IDataRepository<User> userRepository, IDataRepository<Car> carRepository)

    {

        // You can now declare and use "specific" repositories for your Linq objects.

 

        _UserRepository = userRepository;

        _CarRepository = carRepository;

    }

 

    public void DoSomething()

    {

        // Basic get by ID

        var car = _CarRepository.Get(1);

 

        // Complex selector

        var differentCar = _CarRepository.Get(c => c.Name == "Ford");

 

        // Basic list

        var listOfUsers = _UserRepository.List();

 

        // List, with filters

        var filteredUsers = _UserRepository.List()

            .Where(u => u.Name.StartsWith("T"));

 

        // Add

        _UserRepository.Add(new User { Name = "Fred"});

        _UserRepository.SubmitChanges();

 

        // Update

        var editableUser = _UserRepository.Get(1);

        editableUser.Name = "New Name";

        _UserRepository.SubmitChanges();

    }

 

}

Obviously, you can only create a Repository<T> for a class in your context. Otherwise, you would see an epic exception.

Another great thing about this pattern is it's benifits with code-coverage. You can create unit tests for each of these methods and in effect cover your entire data-layer. Not to mention the value in having less code laying around.

OH, and here's that extension method:

public static PropertyInfo GetPrimaryKey(this Type entityType)

{

    foreach (PropertyInfo property in entityType.GetProperties())

    {

        ColumnAttribute[] attributes = (ColumnAttribute[])property.GetCustomAttributes(typeof(ColumnAttribute), true);

        if (attributes.Length == 1)

        {

            ColumnAttribute columnAttribute = attributes[0];

            if (columnAttribute.IsPrimaryKey)

            {

                if (property.PropertyType != typeof(int))

                {

                    throw new ApplicationException(string.Format(

                        "Primary key, '{0}', of type '{1}' is not int", property.Name, entityType));

                }

                return property;

            }

        }

    }

    throw new ApplicationException(string.Format(

        "No primary key defined for type {0}", entityType.Name));

}

 

RepositorySample.zip (9.40 kb)

Tags: , , , ,

IDataContext - Using an Interface for the LinqToSql DataContext

by Jason 4. November 2009 09:23

As you know, I have recently become a huge fan of the Dependency Injection (DI) and Inversion of Control (IoC) patterns, but was stumped when trying to implement this pattern down to my data layer. I LOVE LinqToSQL, but I wasn't sure how I could make the Linq DataContext an abstract interface. I stumbled upon a great article discussing How to make the DataContext "Unit Testable". From this, I boiled down a version of an interface that was easy to implement in the DataContext.

An Interface for the DataContext: IDataContext

LinqToSql exposes Sql Server tables as theunmockable Table which is a sealed class. But LinqToSql namespace has an interface ITable which the Table type implements and that is easy to mock, also this ITable exposes InsertOnSubmit, InsertAllOnSubmit, DeleteOnSubmit, DeleteAllOnSubmit. So in our interface we exposed the ITable instead of that concrete Table which makes this partial Database class completely unit testable.

public interface IDataContext : IDisposable

{

    IQueryable<TEntity> GetQueryable<TEntity>() where TEntity : class;

 

    ITable GetEditable<TEntity>() where TEntity : class;

 

    void Insert<TEntity>(TEntity instance) where TEntity : class;

 

    void InsertAll<TEntity>(IEnumerable<TEntity> instances) where TEntity : class;

 

    void Delete<TEntity>(TEntity instance) where TEntity : class;

 

    void DeleteAll<TEntity>(IEnumerable<TEntity> instances) where TEntity : class;

 

    void SubmitChanges();

 

    int ExecuteCommand(string command, params object[] parameters);

 

    DbConnection Connection { get; }

}

As you can see, all the basic functions of the DataContext exist for your consuming class.

Implement that Sucker

Now we need to implement this interface in our DataContext. Right-click on your DBML file, and select "View Code".  This creates a partial class file for the DataContext. In it, you can implement the interface.

partial class SomeDataContext: IDataContext

{

    public virtual IQueryable<TEntity> GetQueryable<TEntity>() where TEntity : class

    {

        return this.GetTable<TEntity>();

    }

 

    public virtual ITable GetEditable<TEntity>() where TEntity : class

    {

        return this.GetTable<TEntity>();

    }

 

    public void Insert<TEntity>(TEntity instance) where TEntity : class

    {

        this.GetEditable<TEntity>().InsertOnSubmit(instance);

    }

 

    public void InsertAll<TEntity>(IEnumerable<TEntity> instances) where TEntity : class

    {

        this.GetEditable<TEntity>().InsertAllOnSubmit(instances);

    }

 

    public void Delete<TEntity>(TEntity instance) where TEntity : class

    {

        this.GetEditable<TEntity>().DeleteOnSubmit(instance);

    }

 

    public void DeleteAll<TEntity>(IEnumerable<TEntity> instances) where TEntity : class

    {

        this.GetEditable<TEntity>().DeleteAllOnSubmit(instances);

    }

}

Example Usage

Now, your consuming classes are free to use the DataContext as the Interface "IDataContext" which can be mocked in Unit Tests.

public class SomeController

{

    readonly IDataContext _DataContext;

 

    public SomeController(IDataContext dataContext)

    {

        _DataContext = dataContext;

    }

 

    public void DoSomething()

    {

        var foo = _DataContext.GetQueryable<Foo>()

                 .SingleOrDefault(f => f.FooId == 1);

 

    }

}

Conclusion

This demonstrates how you can make your DataContext an interface that is mockable and could be injected at runtime for DI. In the next article, I will show how you can create a generic repository using the IDataContext.

 

Tags: , , ,

Enum<T> - Better Enum Parsing using Strongly-Typed Generics

by Jason 22. October 2009 13:55

When dealing with Enums (parsing, getting values, etc.) there is entirely too much casting and Types being passed around. For instance, to simply parse a string to it’s Enum value, one would do this:

TestEnum testEnum = (TestEnum)Enum.Parse(typeof(TestEnum), "Super");

We had to define the enum type THREE (count them) THREE times, in a single row. Blech! With this helper, this statement becomes much cleaner:

var testEnum = Enum<TestEnum>.Parse("Super");

Only ONE declaration of the Enum type. Nice! (Okay, so I cheated and used the 'var' keyword, but you get the point)

Also, there are some really handy helpers built-in, like:
 TryParse - four overloads, two returning a bool with an out parameter and two that just returns NULL if it fails to parse.
 ToEnumerable - returns a typed-list of all the Enum options

Example:

// Fails parsing, enum value = null

var enumTest = Enum<TestEnum>.TryParse("WrongValue");

 

// Get an IEnumerable of the Enums

var list = Enum<TestEnum>.ToEnumerable();

Plus more goodies -- feel free to take a look.

Now, I am certain that I am not the first to create a generic helper to make parsing Enums easier (article one, article two to name a few) but here is a complete Enum<T> helper class for all your Enum needs. Note, I even recreated all the standard static methods available in Enum, so that there will be no need to pass the “typeof(X)” parameter.

// So this...

string name = Enum<TestEnum>.GetName(TestEnum.Super);

 

// Instead of this...

string name = Enum.GetName(typeof(TestEnum), TestEnum.Super);

Enum<T> Code:

public static class Enum<T>

    where T: struct

{

    public static T Parse(string name)

    {

        return Parse(name, false);

    }

 

    public static T Parse(string name, bool ignoreCase)

    {

        return (T)Enum.Parse(typeof(T), name, ignoreCase);

    }

 

    public static T? TryParse(string name)

    {

        return TryParse(name, false);

    }

 

    public static T? TryParse(string name, bool ignoreCase)

    {

        T value;

        if (!string.IsNullOrEmpty(name) && TryParse(name, out value, ignoreCase))

            return value;

        return null;

    }

 

    public static bool TryParse(string name, out T value)

    {

        return TryParse(name, out value, false);

    }

 

    public static bool TryParse(string name, out T value, bool ignoreCase)

    {

        try

        {

            value = Parse(name, ignoreCase);

            return true;

        }

        catch (ArgumentException)

        {

            value = default(T);

            return false;

        }

    }

 

    public static IEnumerable<T> ToEnumerable()

    {

        foreach (var value in Enum.GetValues(typeof(T)))

             yield return (T)value;

    }

 

    public static IEnumerable<object> GetValues()

    {

        foreach (var value in Enum.GetValues(typeof(T)))

            yield return value;

    }

 

    public static IDictionary<object, string> GetDictionary()

    {

        Dictionary<object, string> dictionary = new Dictionary<object, string>();

        foreach (var value in GetValues())

            dictionary.Add(

                Convert.ChangeType(value, Enum.GetUnderlyingType(typeof(T))),

                GetName(value));

 

        return dictionary;

    }

 

    #region Strongly-Typed Enum Extenders

 

    public static string Format(object value, string format)

    {

        return Enum.Format(typeof(T), value, format);

    }

 

    public static string GetName(object value)

    {

        return Enum.GetName(typeof(T), value);

    }

 

    public static IEnumerable<string> GetNames()

    {

        return Enum.GetNames(typeof(T));

    }

 

    public static Type GetUnderlyingType()

    {

        return Enum.GetUnderlyingType(typeof(T));

    }

 

    public static bool IsDefined(object value)

    {

        return Enum.IsDefined(typeof(T), value);

    }

 

    public static T ToObject(object value)

    {

        return (T)Enum.ToObject(typeof(T), value);

    }

 

    public static T ToObject(byte value)

    {

        return (T)Enum.ToObject(typeof(T), value);

    }

 

    public static T ToObject(sbyte value)

    {

        return (T)Enum.ToObject(typeof(T), value);

    }

 

    public static T ToObject(int value)

    {

        return (T)Enum.ToObject(typeof(T), value);

    }

 

    public static T ToObject(uint value)

    {

        return (T)Enum.ToObject(typeof(T), value);

    }

 

    public static T ToObject(long value)

    {

        return (T)Enum.ToObject(typeof(T), value);

    }

 

    public static T ToObject(ulong value)

    {

        return (T)Enum.ToObject(typeof(T), value);

    }

 

    public static T ToObject(short value)

    {

        return (T)Enum.ToObject(typeof(T), value);

    }

 

    public static T ToObject(ushort value)

    {

        return (T)Enum.ToObject(typeof(T), value);

    }

 

    #endregion

}

Enjoy!

Source Code:

Enum.zip (858.00 bytes)

Tags: , ,

Stack Overflow

Month List