Discussion: recursive typeof patterns

[alrz]

#356 would allow typeof expressions as a pattern to switch on,

Type type = .. ;
switch (type) {
  case typeof(Nullable<int>): ..
  case typeof(Nullable<double>): ..
}

It would be nice to also be able to use discard and var patterns inside a typeof pattern,

if (type is typeof(Nullable<_>)) 
// ->
if (type.IsGenericType && 
    type.GetGenericTypeDefinition() == typeof(Nullable<>))



if (type is typeof(Nullable<var underlyingType>))
// ->
if (type.IsGenericType && 
    type.GetGenericTypeDefinition() == typeof(Nullable<>))
{
  underlyingType = type.GetGenericArguments()[0];
}

Note: t is typeof(Nullable<>) and t is typeof(Nullable<_>) are matching against different types, i.e. the former only matches open types while the latter matches any closed type of Nullable<T>.

Open question: should we generate a call to GetTypeInfo() on the Type first?
Open question: when combined with an as-pattern, what is the type of the variable? Type or TypeInfo?

[YaakovDavis]

Proposed here with more examples.

[Mafii]

This feels very intuitive which is always a great sign for a new feature.

I would like to see that. Great idea!

[HaloFour]

I disagree. I don't think that this belongs as a part of the language given that it's basically shorthand for reflection. I'd rather see better reflection APIs accepted into the BCL or published via NuGet that would simplify these scenarios.

I have written extension methods that allow for such simple interrogation of generic types. I've submitted them to the CoreFX repo but it has stalled. I have reference implementations that I wrote some time ago if you want to peruse:

https://github.com/dotnet/corefx/issues/644

if (type.ImplementsInterface(typeof(IEnumerable<>), out var underlyingType)) {
    // do stuff here
}