C# – Dictionary vs List: Key Differences

That's an interesting take on the factory pattern. I like the combination of the Dictionary and the lambda expression; it made me look at that container in a new way.

I'm ignoring the concern in your question about CPU cycles as you mentioned in the comments that the non-lambda approach doesn't provide what you need.

I think either approach (switch vs. Dictionary + lambda) is going to be fine. The only limitation is that by using the Dictionary, you are limiting the types of inputs you could receive in order to generate the returned class.

Using a switch statement would provide you more flexibility on input parameters. However, if this got to be an issue, you could wrap the Dictionary inside of a method and have the same end result.

If it's new for your team, comment the code and explain what's going on. Call for a team code review, walk them through what was done and make them aware of it. Other than that, it looks fine.

If you check out the source for Nullable<T>, you'll see that the explicit cast operator does this:

public static explicit operator T(Nullable<T> value) {
    return value.Value;
}

And that that Value property does:

public T Value {
    get {
        if (!hasValue) {
            ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NoValue);
        }
        return value;
    }
}

In other words, the cast calls the property and the exception is thrown by the property. So, no, there is no difference between the two options.

Style-wise, we are then into subjectivity. Both are valid and both have been explicitly allowed for by the designers of the type. I'd opt for using the property option, but that's purely personal choice.