The other day I was talking to my old teacher, Jon Wiberg, at "Ljud & Bild skolan". He told me that he had built a extension for the entity framework that enables you to use a strongly typed version of the ".Include()" method in Entity Framework using a lambda expression. I think it´s a lot better approach then just using "magic strings" as a compiletime error is allways better then a runtime error.

So I tought I´d share the code with you here. First we have a static class with a method that gets the name of the property that the expression is pointing at:

public static class Nameof<T>
{
    public static string Property<TProp>(
                                    Expression<Func<T, TProp>> expr)
    {
        var body = expr.Body as MemberExpression;
        if (body == null)
            throw new ArgumentException(
                       "Parameter expr must be a memberexpression");


        return body.Member.Name;
    }
}

And here is the extension method itself:

public static ObjectQuery<T> Include<T, Tprop>(
              this ObjectQuery<T> q, Expression<Func<T, Tprop>> expr)
{
    return q.Include(Nameof<T>.Property<Tprop>(expr));
}

I implementet this in a project that I´m working on, and it works nicely. Say NO to magic strings. Any credit goes to Jon as I´m only sharing his code.