如何使用泛型类型参数传入func？

Question

I like to send a generic type converter function to a method but I can't figure out how to do it.

Here's invalid syntax that explains what I like to achieve, the problem is I don't know how to specify the generic type together with my func:

public void SomeUtility(Func<T><object,T> converter)
{
    var myType = converter<MyType>("foo");
}

Edit (see also my discussion in the comments with Lawrence) : By "generic type converter" I meant I would like to pass in a converter that can convert to any strong type <T> (not object), so the next line in my method could be:

var myOtherType = converter<MyOtherType>("foo");

The delegate I like to pass as a parameter would look something like this:

private delegate TOutput myConverterDelegate<TOutput>(object objectToConvert);

This is more a syntax / C# exploration now, to get things done I will probably use an interface instead, but I do hope this is possible to accomplish with a func/delegate.

Answer 1

You cannot have instances of generic functions or actions - all type parameters are defined upfront and cannot be redefined by the caller.

An easy way would be to avoid polymorphism altogether by relying on down-casting:

public void SomeUtility(Func<Type, object, object> converter)
{
    var myType = (MyType)converter(typeof(MyType), "foo");
}

If you want type safety, you need to defer the definition of the type parameters to the caller. You can do this by composing a generic method within an interface:

public void SomeUtility(IConverter converter)
{
    var myType = converter.Convert<MyType>("foo");
}

interface IConverter
{
   T Convert<T>(object obj);
}

Edit:

If the 'converter type' is known at the call-site, and only this type will be used inside the utility method, then you can define a generic type on the method and use that, just like other posters have suggested.

Answer 2

public void SomeUtility<T>(Func<object, T> converter)
{
    var myType = converter("foo");
}

and then:

SomeUtility(arg => new MyType());

The generic type inference will work in this case.

Answer 3

You need to make SomeUtility generic as well. Doing this and fixing the syntax gives:

public void SomeUtility<T>(Func<object,T> converter)
{
    var myType = converter("foo");
}

Answer 4

You have to know the T type at compile-time to use it. The T can either be specified at class-level or at method-level.

class SomeClass<T> {
    public void SomeUtility(Func<object, T> converter) {
        var myType = converter("foo"); // Already is the T-type that you specified.
    }
}

or

public void SomeUtility<T>(Func<object, T> converter) {
    var myType = converter("foo"); // Already is the T-type that you specified.
}