Understanding C# Covariance And Contravariance (3) Variances in .NET

Understanding C# Covariance And Conreavariance:

Not many generic types in .NET have variant type parameter(s). LINQ can be uses to query these generic types from .NET libraries.

The following method queries a specified directory, and retrieve all .NET assemblies:

1
public static partial class ReflectionHelper
2
{
3
    public static IEnumerable<Assembly> GetAssemblies(string directory)
4
    {
5
        return Directory.EnumerateFiles(directory, "*.dll")
6
            .Select(file =>
7
                {
8
                    try
9
                    {
10
                        return Assembly.LoadFrom(file);
11
                    }
12
                    catch (BadImageFormatException)
13
                    {
14
                        return null;
15
                    }
16
                })
17
            .Where(assembly => assembly != null);
18
    }
19
}

The following method queries one specified assembly, and filter generic types with any variant type parameter:

1
public static partial class ReflectionHelper
2
{
3
    public static IEnumerable<Type> GetTypesWithVariance(Assembly assembly)
4
    {
5
        try
6
        {
7
            return assembly.ExportedTypes.Where(type =>
8
                type.IsGenericTypeDefinition && type.GetGenericArguments().Any(argument =>
9
                    (argument.GenericParameterAttributes & GenericParameterAttributes.Covariant)
10
                    == GenericParameterAttributes.Covariant
11
                    ||
12
                    (argument.GenericParameterAttributes & GenericParameterAttributes.Contravariant)
13
                    == GenericParameterAttributes.Contravariant));
14
        }
15
        catch (TypeLoadException)
16
        {
17
            return Enumerable.Empty<Type>();
18
        }
19
    }
20
}

The last method queries the assemblies in the same directory of mscorlib.dll, and retrieves the wanted types, and orders them by name:

1
public static partial class ReflectionHelper
2
{
3
    public static IEnumerable<Type> GetTypesWithVariance()
4
    {
5
        string mscorlibPath = typeof(object).Assembly.GetName().CodeBase;
6
        string directory = Path.GetDirectoryName(new Uri(mscorlibPath).AbsolutePath);
7
        return GetAssemblies(directory)
8
            .SelectMany(GetTypesWithVariance)
9
            .OrderBy(type => type.Name);
10
    }
11
}

Here is the result of executing the last method:

System namespace:
- Action`1 to Action`16, Func`1 to Func`17
- Comparison<T>
- Converter`2
- IComparable<T>,
- IObservable<T>, IObserver<T>
- IProgress<T>
- Predicate<T>
System.Collections.Generic namespace:
- IComparer<T>, IEqualityComparer<T>
- IEnumerable<T>, IEnumerator<T>
- IReadOnlyCollection<T>, IReadOnlyList<T>
System.Linq namespace:
- IGrouping`2
- IOrderedQueryable<T>, IQueryable<T>

MSDN has a List of Variant Generic Interface and Delegate Types, but it is inaccurate. For example, it says TElement is covariant for IOrderedEnumerable<TElement>, but actually not:

1
namespace System.Linq
2
{
3
    public interface IOrderedEnumerable<TElement> : IEnumerable<TElement>, IEnumerable
4
    {
5
        IOrderedEnumerable<TElement> CreateOrderedEnumerable<TKey>(Func<TElement, TKey> keySelector, IComparer<TKey> comparer, bool descending);
6
    }
7
}