Nothing is not null

I have to switch between writing legacy vb.net and c# on a daily basis and generally don't find this to be much of a problem, but a came across an interesting difference when trying to find the equivalent of c#'s default keyword. The default keyword returns the default value for a type T: default(T), zero for numeric types, null for nullables etc. It turns out that Nothing can be used in vb.net in this way. I always assumed null and Nothing where equivalent between vb.net and c#; I was wrong.

null == 0 // False
Nothing = 0 ' True

false == null // False
False = Nothing ' True

Taken from the official documentation: Nothing represents the default value of any data type. For reference types, the default value is the null reference. For value types, the default value depends on whether the value type is nullable.

There doesn't appear to be an equivalent of pure null in vb.net, you would have to check if it was a reference or value type explicitly. I don't like the implicitness of Nothing, but it fits with vb.net's general implicit conversions (which I also don't like).

False = 0 ' True
"1" = 1 ' True
' etc. etc.

Anonymous function in anger with Memoize

About a year ago I blogged about anonymous functions, lambdas and delegates. I've had cause to use these principals in anger to create a memoize function; not exactly original but interesting never the less. I made this memoize function, which takes an anonynous function that takes 2 parameters.

static Func<T1, T2, TResult> Memoize<T1, T2, TResult>(Func<T1, T2, TResult> f)
{
    var dict = new Dictionary<Tuple<T1, T2>, TResult>();
    return (a, b) =>
    {
        TResult result;
        if (!dict.TryGetValue(Tuple.Create(a, b), out result))
        {
            result = f(a, b);
            dict.Add(Tuple.Create(a, b), result);
        }
        return result;
    };
}

N.B. It uses the .net4 Tuple class to store the 2 parameters, for the sake a simplicity I haven't generalized this for 1 or > 2 parameters, or made it an extension method. You then need to wrap the function you want memoizing.

var myFunc1 = Memoize((Func<int, int, MyClass1>)Some.Dot.Namespace.Func1);
var myNewClass = new MySomethingClass();
var myFunc2 = Memoize((Func<string, string, MyClass2>)myNewClass.Func2);

while(true)
{
    var result = myFunc1(1,2);
    var result2 = myFunc2("1","2");
}

The results of the memoized functions are cached inside the function calls, leading to better performance if the function is a called with the same parameters many times in the loop.

The curious case of null coalescing arithmetic

or how the simple things trip you up

I was writing a quick bit of code to add two nullable integers. To cope with the null, I used the wonderfully simple null coalescing operator ?? in C# to convert the integers to zero, like this:

int result = a ?? 0 + b ?? 0;

The result was wrong as demonstrated below:

int? a = 2;
int? b = 4;

int c = a ?? 0 + b ?? 0;
// Result:
// c = 2;

The obvious answer was a problem with operator precedence and a few brackets later fixed the problem:

int c = (a ?? 0) + (b ?? 0);
// Result:
// c = 6;

But why was it doing in the first instance? A little playing with linqpad later and it turns out the + operator has a much higher precedence than ??, so it was actually doing:

int c = a ?? ((0 + b) ?? 0);

This reads as: a, or if a is null then 0 + b, if 0 + b is null then zero. The mistake I made was because I'm so used to using ?? as a simple substitution of the preceding variable I wasn't thinking of it as a 'real' operator with precedence and ordering.

Asp.net will actually let you handle errors like this

VB.Net on a ASP.Net completely legit web page will do this:

    Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load

        On Error GoTo OwDear
Stupid:
        On Error Resume Next
        Throw New Exception("Dun gone wrong.")
        On Error GoTo OwDear
        Throw New Exception("Another error.")
OwDear:
        MsgBox("Another error.")

    End Sub

Documented: http://msdn.microsoft.com/en-us/library/5hsw66as.aspx This is just awful!

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();