There should be a way to extract type parameters of generic type parameter as type parameters to invoke another generic

[qaqz111]

This is an old question.

namespace XSerializer.NUnitTest
{
    using System;
    using System.Collections.Generic;

    public class XSerializer
    {
        public int Write<T>(T obj) => 1;
        public int Write<T>(IEnumerable<T> objs) => 2;
    }

    public class TstClass
    {
        public void Foo()
        {
            var x = new XSerializer();
            x.Write(DateTime.Now); //1

            x.Write("Hello world!"); //1!
            x.Write((IEnumerable<char>)"Hello world!"); //2

            x.Write(new int[4]); //1!
            x.Write((IEnumerable<int>)new int[4]); //2
        }
    }
}

As you can see, the 2nd Write will never be called unless you explicitly convert the object to IEnumerable<XXX>.

Previously there is an issue suggested allow not constraint to generics to address this problem, but it seems that there is a very long way to go for that.

• Allow 'not' generic type constraints Allow 'not' generic type constraints #707

For now, the solution should look like this:

namespace XSerializer.NUnitTest
{
    using System;
    using System.Collections.Generic;
    using System.Linq;

    public class XSerializer
    {
/******************************************************************************/
/*                                                                            */
        public int Write<T>(T obj)
        {
            var type = obj.GetType();

            if (type.IsArray)
            {
                return (int)typeof(XSerializer)
                    .GetMethods()
                    .First(mi => mi.ToString() == "Int32 Write[T](System.Collections.Generic.IEnumerable`1[T])")
                    .MakeGenericMethod(type.GetElementType())
                    .Invoke(this, new object[] { obj });
            }

            if (type.IsGenericType)
            {
                if (typeof(IEnumerable<>).MakeGenericType(type.GenericTypeArguments).IsAssignableFrom(type))
                {
                    return (int)typeof(XSerializer)
                        .GetMethods()
                        .First(mi => mi.ToString() == "Int32 Write[T](System.Collections.Generic.IEnumerable`1[T])")
                        .MakeGenericMethod(type.GenericTypeArguments)
                        .Invoke(this, new object[] { obj });
                }
            }
            return 1;
        }
/*                                                                            */
/******************************************************************************/
        public int Write<T>(IEnumerable<T> objs) => 2;
    }

    public class TstClass
    {
        public void Foo()
        {
            var x = new XSerializer();
            x.Write(DateTime.Now); //1

            x.Write("Hello world!"); //2 (previously 1)
            x.Write((IEnumerable<char>)"Hello world!"); //2


            x.Write(new int[4]); //2 (previously 1)
            x.Write((IEnumerable<int>)new int[4]); //2
        }
    }
}

If there is a way to extract type parameters of a generic type parameter as a type parameter, we can do this:

namespace XSerializer.NUnitTest
{
    using System;
    using System.Collections.Generic;

    public class XSerializer
    {
/******************************************************************************/
/*                                                                            */
        public int Write<T>(T obj)
        {
            if (obj.GetType().IsArray || obj.GetType().IsGenericType)
            {
                if (obj is IEnumerable<typeparameterof(T, 0)> enumerable)
                    return Write(enumerable);
            }
            return 1;
        }
/*                                                                            */
/******************************************************************************/
        public int Write<T>(IEnumerable<T> objs) => 2;
    }

    public class TstClass
    {
        public void Foo()
        {
            var x = new XSerializer();
            x.Write(DateTime.Now); //1

            x.Write("Hello world!"); //2 (previously 1)
            x.Write((IEnumerable<char>)"Hello world!"); //2


            x.Write(new int[4]); //2 (previously 1)
            x.Write((IEnumerable<int>)new int[4]); //2
        }
    }
}

The point is typeparameterof(T, 0), which extracts the 1st type argument from obj's type.

---

Yes, for this particular scenario, there is a trick to play with:

namespace XSerializer.NUnitTest
{
    using System;
    using System.Collections.Generic;

    public class XSerializer
    {
        public int WriteNotIEnumerable<T>(T obj) => 1; //<- name changed!
        public int Write<T>(IEnumerable<T> objs) => 2;
    }

/******************************************************************************/
/*                                                                            */
    public static class XSerializerExtension
    {
        public static int Write<T>(this XSerializer x, T obj) => x.WriteNotIEnumerable(obj);
    }
/*                                                                            */
/******************************************************************************/

    public class TstClass
    {
        public void Foo()
        {
            var x = new XSerializer();
            x.Write(DateTime.Now); //1 -> ext method

            x.Write("Hello world!"); //2 (previously 1)
            x.Write((IEnumerable<char>)"Hello world!"); //2


            x.Write(new int[4]); //2 (previously 1)
            x.Write((IEnumerable<int>)new int[4]); //2
        }
    }
}

But, if you think this trick can solve the problem perfectly, you are too young too simple.

namespace XSerializer.NUnitTest
{
    using System;
    using System.Collections.Generic;

    public class XSerializer
    {
        public int WriteNotIEnumerable<T>(T obj) => 1;
        public int Write<T>(IEnumerable<T> objs) => 2;
    }

    public static class XSerializerExtension
    {
        public static int Write<T>(this XSerializer x, T obj) => x.WriteNotIEnumerable(obj);
    }

    public class TstClass
    {
/******************************************************************************/
/*                                                                            */
        public void Foo()
        {
            Bar(DateTime.Now); //1 -> ext method

            Bar("Hello world!"); //1! -> ext method
            Bar((IEnumerable<char>)"Hello world!"); //1!!! -> ext method


            Bar(new int[4]); //1! -> ext method
            Bar((IEnumerable<int>)new int[4]); //1!!! -> ext method
        }

        public void Bar<T>(T obj)
        {
            var x = new XSerializer();
            x.Write(obj); //-> ext method only!
        }
/*                                                                            */
/******************************************************************************/
    }
}

---

It looks like this big piece of code would be the only solution for now:

var type = obj.GetType();

if (type.IsArray)
{
    return (int)typeof(XSerializer)
        .GetMethods()
        .First(mi => mi.ToString() == "Int32 Write[T](System.Collections.Generic.IEnumerable`1[T])")
        .MakeGenericMethod(type.GetElementType())
        .Invoke(this, new object[] { obj });
}

if (type.IsGenericType)
{
    if (typeof(IEnumerable<>).MakeGenericType(type.GenericTypeArguments).IsAssignableFrom(type))
    {
        return (int)typeof(XSerializer)
            .GetMethods()
            .First(mi => mi.ToString() == "Int32 Write[T](System.Collections.Generic.IEnumerable`1[T])")
            .MakeGenericMethod(type.GenericTypeArguments)
            .Invoke(this, new object[] { obj });
    }
}

So, I think we need operators to extract information about generic types:

typeparameterof(T, n) //-> extract nth type parameter of a generic type parameter

typeparameterscountof(T) //-> return number of type parameters of a generic type parameter, of course 0 means it is not a generic type

And, these operators should work with array types too, although they are not considered as generic type by compiler for now.

If the typeparameterscountof(T) can be implemented, the code will be more simpler:

    if (1 == typeparameterscountof(T) &&
        obj is IEnumerable<typeparameterof(T, 0)> enumerable)
    {
        return Write(enumerable);
    }

Of course the literal name of operators can be simplified, like tparamof()/tparam(), tcountof()/tcount(), etc.

[Happypig375]

Will higher kinded polymorphism (#339) help you?

[qaqz111]

Yeah, I've read that post before.

The idea of HKP indeed focused on the same aspect of generics with what I described above, but I wish to call it generics on generics as the author @gafter of that post subtitled which is easier to understand.

But some kind of different.

In my opinion, HKP uses **known** type parameters on **user supplied** generic type definition to generate a new type parameter, the point I described is to extract type parameters from a known type parameter generated by a generic type definition and **type parameters** supplied to it.

So, the point of HKP is to generate:

type parameters + **user supplied** generic type definition -> new type parameter

And the point of tparam()/tcount() is to extract:

known type parameter -> type parameters

Once you get type parameters you can do any thing you want.

The code above is just one example in a scenario of serializer implementation, in fact we encountered many scenarios that can make use of tparam()/tcount(), if they were implemented in C#.

[orthoxerox]

@qaqz111 It's the same problem from two different standpoints, since in both cases the CLR has to support generic parameters having generic parameters of their own. Right now you cannot express this, so there's no way to extract the parameter during the execution.

[Happypig375]

obj is IEnumerable<typeparameterof(T, 0)> enumerable

Java wildcards?
obj is IEnumerable<?> enumerable

[bbarry]

There is another trick:

public class XSerializer {
    public int Write(dynamic obj) => WriteNotIEnumerable(obj); // dynamic 
    private int WriteNotIEnumerable<T>(T obj) => 1; // renamed
    public int Write<T>(IEnumerable<T> objs) => 2;
}

(not disagreeing that it would be nice to have some attention paid to generics though)