Question

This is a simple contrived example, but hopefully will illustrate my query.

public class Test
{
    public string Name = "test";
}


public static class Ext 
{
     public static Test ConvertToTest<T1>(this T1 source) 
     {
         return new Test();
     }

     public static T2 Convert<T1,T2>(this T1 source) where T2 : new()
     {
         return new T2();
     }
}

ConvertToTest only needs one Type, so the following compile

    Ext.ConvertToTest<string>("hello");
    "hello".ConvertToTest();

The last uses type-interfence and this means it also works with anonymous classes, eg

    var anon = (new { Name = "test" }) ;
    anon.ConvertToTest();

However this is hardcoded to always use the class Test, whereas I want to be able to specify the type as in the second method

I can write

   Ext.Convert<string, Test>("hello");

and this compiles, because I know both types at compile time, but I can’t use it with anonymous classes, and I can’t find a way of using type-inference plus the extra Type

It would be nice if I could do something like

    anon.Convert<,Test>()  ;

and the compiler would know to use inference for the first type (which isn’t specified) and use Test as the second type.

Is there any way around this issue?

Answer 1

You can’t do what you’re asking on a single method, but if you’re clever and willing to define a couple of different classes you should be able to make syntax like this possible:

var test = Ext.Convert("hello").To<Test>();

Just make Convert be based on a single generic type, and have it return a generic type based on that:

public Converter<T> Convert<T>(T source)
{
    return new Converter<T>(source);
}

Then add a method to the type it returns which serves as a basic wrapper for your original method:

public class Converter<T>
{
    T _source;
    internal Converter(T source)
    {
        _source = source;
    }
    public T2 To<T2>()
    {
        return Ext.Convert<T, T2>(_source);
    }
}