C# Anonymous, Lambdas, Delegates and Expressions...phew.

C# and by extension any .net language has complex support for both anonymous functions and lambdas. I found it quite useful to have a basic reference for these; so here it is.

// Anonymous function using the delegate keyword.
Func<string> anon = delegate() { return "x"; });

// Anonymous function from lambda.
Func<string> lambda = () => "x";

// Same but using explicit typing.
var anon2 = new Func<string>(delegate() { return "x"; });

The function references (anon, lambda, anon2) are known in .net as delegates which is nomenclature for function pointer. Because C# is statically typed we have to explicitly type the delegate, hence 'Func'. Func is a generic delegate type: a predefined delegate, rather than having to specify it constantly. We could explicity define the delegate like this.

// Define delegate.
delegate int myDelegate(int i);

// Assign delegate.
myDelegate anon = delegate(int i) { return i };
myDelegate lambda = x => x + 1;

Linq Expressions is where things start to get more complex. Linq expressions allow lambda functions to be reflected and turned into data instead of code, allowing you to change the function. A typical change would be from a .net lambda function to an SQL statement.

// Expression
Expression<Func<string>> exp = () => "x";

// Can't be done.
// Expression<Func<string>> exp2 = delegate() { return "x"; };

However note that Linq Expressions cannot be created using anonymous functions.

OK if you followed all that....lambda can also be written with a statement body rather than an expression body as we have seen so far. Statement bodies allow more complex multiline functions.

// Statement lambda
Func<string> lambda = () => { return "x"; };

Statement and expression body lambdas are functionaly identical, but they are different. Statement body lambdas cannot be made into expression trees. In practice this means that certain linq providers, such as Linq2Sql cannot use lambda functions created with statement bodies.

A lambda expression with a statement body cannot be converted to an expression tree

One final quirk I'll mention is that once you have an explicit Expression it can be used on an IQueryable, but not a standard IEnumerable. You have to 'unwrap' it, converting it back to a standard Func.

// OK, compiler sorts it out
var l0 = new int[] { 1, 2, 3 }.Where(x => x < 2);
var l1 = new int[] { 1, 2, 3 }.AsQueryable<int>().Where(x => x < 2);

// Force exp to be an Expression
Expression<Func<int, bool>> exp = x => x < 2;

// Doesn't work - invalid arguments
//var l2 = new int[] { 1, 2, 3 }.Where(exp);

// Works on IQueryable
var l3 = new int[] { 1, 2, 3 }.AsQueryable<int>().Where(exp);

// Convert Expression back to standard Func to make it work.
var l4 = new int[] { 1, 2, 3 }.Where(exp.Compile());

C# Optional Arguments Gotcha

I came across an interesting quirk of C#'s optional arguments when coding a MVC site against my Linq2Sql BLL. The BLL handles all my database logic including the creation of the Linq DataContext. In some edge cases I need to recycle an existing DataContext; so I made the DataContext an optional parameter. All good until I instantiated a new instance of the BLL in my shiny new MVC website - new BLL() - and encountered this error:

Error 11 The type 'System.Data.Linq.DataContext' is defined in an assembly that is not referenced.

Apparently the calling code must know about the optional object type even when it's not specified. After some googling it looks like the optional parameters are baked directly into the IL at compile time. It wouldn't make sense to do this on the callee side, so this seems very odd behaviour.

Interfaces on Anonymous function revisted in C#

Last year I wrote a blog about adding interfaces to anonymous functions in Python. Since then I have being programming in .Net (C# and VB.Net) and was curious to see how easy it would be to achieve something similar in C#. I'm not using any IoC frameworks in C# so I wrote a very stupid one just for testing.

C# differs in a few key areas. You can't modify an object’s properties at runtime in C# without doing some Assembly hacking and even if you could, you can't add interfaces to anonymous or lamdba functions. So adding an interface and then adapting a runtime object based on its interfaces isn’t possible, so I ended up having to pass both interfaces around at all points (not ideal). The other major difference is that C# requires strict typing of the anonymous function so you can see 2 explicit casts in the code.

This isn’t the correct way of achieving this in C# but I found the contrast of coding something Pythonic in a different language interesting.

public interface IConcreteInterface { }
public interface ILambdaExpression { }

public class AdapterManager
{
    protected readonly List<Adapter> services = new List<Adapter>();

    public void registerAdapter<T, U>(object val)
    {
        var adapter = new Adapter() {
            adapts = typeof(U),
            implements = typeof(T),
            val = val
        };
        services.Add(adapter);
    }

    public object resolve<T, U>()
    {
        return (from x in services where x.adapts == typeof(U) && x.implements == typeof(T) select x.val).Single();
    }
}

var gsm = new AdapterManager();
gsm.registerAdapter<IConcreteInterface, ILambdaExpression1>((Func<string>)(() => "Hello World"));

var adapted = gsm.resolve<IConcreteInterface, ILambdaExpression1>();
var lambdaExp = (Func<string>)result
var result = lambdaExp();