Back when I wrote the article, dynamic typing wasn’t yet available in C#.

public static Pair FirstTwoValues(Node node)
{
if( node == null ) throw new ArgumentException();
if( node.Next == null ) throw new ArgumentException();

dynamic first = node;
dynamic next = node.Next;

return MakePairImpl(first, next);
}

private static Pair MakePairImpl<TFirst, TNext>(Node<TFirst> first, Node<TNext> next)
{
return new Pair<Node<TFirst>, Node<TNext>>(first, next);
}

But there is a fourth option

Recently I was solving just about the same problem. Here is what I came up with:

public static Pair FirstTwoValues(Node node)
{
if( node == null ) throw new ArgumentException();
if( node.Next == null ) throw new ArgumentException();

dynamic first = node;
dynamic next = node.Next;

return MakePair(first, next);
}

private static Pair MakePair(Node first, Node next)
{
return new Pair<Node, Node>(first, next);
}

That trick relies on DLR being able to figure out (under the hood) the exact runtime types of the nodes.

This is somewhat similar to the reflection-based approach and should have the same performance penalties.. But looks much nicer from the C# code perspective and devoid of the downsides of the 3rd option you outlined.

Hope that will also be useful to the readers of your blog.

Andrey

To get into a context where U and V type variables are available, you need to use one of the techniques described in the article (i.e., big switch statement, reflection, or virtual method call).