'is' pattern matching for generic types

[sjb-sjb]

Would be very convenient to be able to test for a generic type using 'is', like this:

IList x = ...
if (x is List<Type t> xx) {
   xx.Sort();
   if (t.IsAssignableTo(typeof(int)) { ... }
}

Obviously there are other ways to do this such as (a) using dynamic variables (b) factoring the method call (Sort, in this example) up into a nongeneric base class (c) using reflection. All of those approaches however are worse in one way or another.

[ZacharyPatten]

What are you expecting xx.Sort(); to do? The compiler needs to know the type of xx in order to call the appropriate Sort method. What if you did not have a using System.Collections.Generic; but you did have an extension method Sort for List<T> in the scope of that code? What you appear to be asking for would likely not be type-safe.

Here is comparable code to the example:

using System;
using System.Collections;
using System.Collections.Generic;

IList IList = new List<int>() { 3, 2, 1 };
Type List = IList.GetType();
if (List.IsGenericType && List.GetGenericTypeDefinition() == typeof(List<>))
{
	List.GetMethod("Sort", Array.Empty<Type>()).Invoke(IList, default);
	Type T = List.GetGenericArguments()[0];
	if (T.IsAssignableTo(typeof(int)))
	{
		foreach (var o in IList)
		{
			Console.WriteLine(o);
		}
	}
}

You should try to avoid using System.Collections.IList in favor of using System.Collections.Generic.IList<T> in general. Often times if you are in that situation in your code, you could have redesigned other portions of the code so you do not lose type safety by using base types like IList or object.

[ZacharyPatten]

But that is the problem. What you are asking for is essentially the same as casting the IList to a dynamic and calling Sort on it.

using System;
using System.Collections;
using System.Collections.Generic;

IList IList = new List<int>() { 3, 2, 1 };
Type List = IList.GetType();
if (List.IsGenericType && List.GetGenericTypeDefinition() == typeof(List<>))
{
	dynamic d = IList;
	d.Sort();
	Type T = List.GetGenericArguments()[0];
	if (T.IsAssignableTo(typeof(int)))
	{
		foreach (var o in IList)
		{
			Console.WriteLine(o);
		}
	}
}

The compiler can't/shouldn't assume which "Sort" you want to call.

The compiler needs to know the method at compile time.

[sjb-sjb]

Right, that’s pretty much what I want it to do, I just want it to be way easier than writing all the reflection / dynamic code myself.

To answer your earlier question, if there were no “using System.Collection.Generic” then one would not be able to write the “is” statement. If there is also a Sort extension method then xx.Sort() should invoke the same method as yy.Sort() does when yy has static type List<T> where typeof(T) == t. I think that is very do-able.

[HaloFour]

Given the performance overhead and brittleness of reflection/dynamic code it seems unwise to have the compiler encourage it, especially hidden behind what appears be type safe code. I'd rather runtime support for generic wildcards than attempting to fake it in the compiler.

[sjb-sjb]

@HaloFour What do you mean by runtime support for generic wildcards?

[HaloFour]

The ability to declare variables of unbound or partially bound generic types and to check at runtime whether an instance is compatible with those types. Something like this:

IList x = ...
if (x is List<?> xx) {
   xx.Sort();
   ...
}

You'd be permitted to safely call methods that don't have the generic type as an input or output, such as Sort, but you could lot call Add or Item[].

To take it a step further bounded wildcards could be used to enable some variance where the generic type is specifically of a reference type. This would enable calling more methods safely

// given
class Person { }
sealed class Student : Person { }
IList x = ...;

// covariance, can match List<Person> or List<Student>
if (x is List<? extends Person> xco) {
    // always legal, method has no generic inputs or outputs
    xco.Sort();

    // legal
    Person person = xco[0];

    // compiler error
    xco.Add(new Person());
}

// contravariance, can match List<Person> or List<object>
if (x is List<? super Person> xcon) {
    // always legal, method has no generic inputs or outputs
    xcon.Sort();

    // compiler error
    Person person = xcon[0];

    // legal
    xcon.Add(new Person());
}

Java has this functionality, but of course Java is more flexible with generics in general since they are a compile-time hack. Any such support for wildcards in C# would need to come from the runtime, otherwise the compiler would be forced to rely on reflection or dynamic. I've also borrowed the syntax from Java, I assume that it would look different in C#.

[svick]

This is a duplicate of #1225.