Delegates with return value type inference (C#)

Question

I'm still new to delegates and I've been playing with the Delegate-based Data Access Layer described in Steven John Metsker's "Design Patterns in C#" book (an excellent read!). It defines the data access delegate like this:

public delegate object BorrowReader(IDataReader reader);

The result of using this is code that looks like one of these:

var result = Foo.Bar(new BorrowReader(DoFooBarMagic));
var result = Foo.Bar(DoFooBarMagic);

However, since the delegate's return type is "object", you need to cast to get whatever the method ("DoFooBarMagic" in this example) really returns. So if "DoFooBarMagic" returns List, you'd need to do something like this:

var result = Foo.Bar(DoFooBarMagic) as List<string>;

What I'd like is to be able to skip the cast and have the return type of the delegate inferred from the return type of the delegate method. My thought was maybe there's a way to use a Type parameter to inference the return type. Something like one of these:

public delegate T BorrowReader<T>(IDataReader reader);
List<string> result = Foo.Bar(new BorrowReader(DoFooBarMagic)); 
//Look, Ma, no cast!
var result2 = Foo.Bar(DoFooBarMagic);

Where the type of the return is inferred from the return type of the delegate method, but that appears not to work. Instead you have to do this:

public delegate T BorrowReader<T>(IDataReader reader);
var result = Foo.Bar(new BorrowReader<List<string>>(DoFooBarMagic));

Which hardly seems better than the cast.

So is there a way to infer the return type of the delegate from the return type of the delegate method?

Edit to Add: I can change the signature of Foo.Bar if need be. The current signature is essentially this:

public static T Bar<T>(string sprocName,
                       DbParameter[] params, 
                       BorrowReader<T> borrower);

Note: that signature is the result of the current state, which is using this delegate definition:

public delegate T BorrowReader<T>(IDataReader reader);

Answer 1

It's ugly, but you can use an out parameter. From my enum parser:

public static T Parse<T>(string value)
{
    // return a value of type T
}

public static void Parse<T>(string value, out T eValue)
{
    // do something and set the out parameter
}

// now can be called via either
SomeEnum blah = Enums.Parse<SomeEnum>("blah");

// OR
SomeEnum blah;
Enums.Parse("blah", out blah);

The second one will infer the type, but like I said, it's ugly.

Answer 2

Not using generics. Type inference is a compile-time event. One solution would be to have a generic delegate as you posted. The generic delegate would be faster than a cast.

Answer 3

I don't think there's a way around it. At least not in the way you propose it. The main problem being that since it has to be infered at compile time, if you don't have an explicit return type, then the compiler can't actually infer the return type.

Answer 4

How about:

public static T Bar2<T>(Func<IDataReader,T> func) where T : class
{
    BorrowReader borrower = new BorrowReader(func);
    return (T) Foo.Bar(borrower);
}

I know it's still doing the cast anyway, which is ugly, but it should work. (I originally thought you could get away with an implicit conversion from func, but apparently not. At least not before C# 4.0.)

Of course, if you can change the signature of Foo.Bar to be generic, you're laughing...

EDIT: To answer the comment: if the signature of the method is changed to take a generic delegate, e.g.

public static T Bar<T>(Funct<IDataReader, T> func)

then the calling code can nearly just be:

var result = Foo.Bar(DoFooBarMagic);

Unfortunately, type inference doesn't work with method groups so you have to use either:

Func<IDataReader, List<string>> func = DoFooBarMagic;
var result = Foo.Bar(func);

or (nicer, if slightly less efficient)

var result = Foo.Bar(reader => DoFooBarMagic(reader));

So you're right - this answer didn't quite get the OP to exactly what was required, but presumably it came close enough to get acceptance. Hopefully this edit is helpful to explain the rest :)

Answer 5

I can't get the accepted answer to work. No type inference occurs. What am I missing?

public delegate object BorrowReader(IDataReader reader);

public class Foo
{
    public static object Bar(BorrowReader del)
    {
     return null;
    }

    public static T Bar2<T>(Func<IDataReader, T> func) where T : class
    {
     var borrower = new BorrowReader(func); 
     return (T) Foo.Bar(borrower);
    }

    public static List<String> DoFooBarMagic(IDataReader reader)
    {
     return new List<string>();
    }

    public void Compiles()
    {
     var result = Foo.Bar2<List<string>>(Foo.DoFooBarMagic);
    }

    public void DoesNotCompile()
    {
     var result = Foo.Bar2(Foo.DoFooBarMagic);
     // The type arguments for method 'Foo.Bar2<T>(System.Func<System.Data.IDataReader,T>)' 
     // cannot be inferred from the usage. Try specifying the type arguments explicitly. 
    }
}

Answer 6

// if BorrowReader is generic...
public delegate T BorrowReader<T>(IDataReader reader);

public class Foo
{
    // ... and Foo.Bar() is also generic
    public static T Bar<T>(BorrowReader<T> borrower) { ... }

    public void SomeMethod()
    {
        // this does *not* work (compiler needs more help)
        var result1 = Foo.Bar(DoFooBarMagic);

        // but instead of this (which works)
        var result2 = Foo.Bar(new BorrowReader<List<string>>(DoFooBarMagic));

        // you can do this (also works)
        // which emits the same IL, anyway
        var result3 = Foo.Bar<List<string>>(DoFooBarMagic);
    }
}