Question

I have 2 overloaded C# functions like this:

private void _Insert(Hashtable hash, string tablename, Func<string, object[], SqlCommand> command)
private void _Insert(Hashtable hash, string tablename, Func<string, object[], OleCommand> command)

Basically one using OleCommand and the other SqlCommand for the return value of the function.

But the ugly thing about this is that I have to cast the function pointer to the correct type even though i feel the compiler should be able to resolve it without problems:

class RemoteDatabase
{    
      public SqlCommand GetCommand(string query, object[] values);
}

_Insert(enquiry, "Enquiry", (Func<string, object[], SqlCommand>)(_RemoteDatabase.GetCommand));

Is there any way tell the compiler to be smarter so that I don’t have to do the type casting? Or did I do anything wrong?

EDIT:
Added a bounty because I am really interested to learn. Thanks for any advice.

Answer 1

While not answering your question directly, I did come across the following while writing up a test case, you can get it to compile by wrapping the call in another lambda. Which removes the explicit cast at the cost of another method call (at least I think so, haven’t looked at the IL yet)

class RemoteDatabase
{
    public int GetCommand(){return 5;}
}

class Program
{

    static void Main(string[] args)
    {
        var rd = new RemoteDatabase();

        // Overloaded(1, rd.GetCommand); // this is a compile error, ambigous

        Overloaded(1, () => rd.GetCommand()); // this compiles and works

        Console.ReadLine();
    }

    static void Overloaded(int paramOne, Func<int> paramFun)
    {
        Console.WriteLine("First {0} {1}", paramOne, paramFun());
    }

    static void Overloaded(int paramOne, Func<string> paramFun)
    {
        Console.WriteLine("Second {0} {1}", paramOne, paramFun());
    }
}

EDIT-
I found this post by Eric Lippert that answers this question

An interesting fact: the conversion rules for lambdas do take into
account return types. If you say Foo(()=>X()) then we do the right
thing. The fact that lambdas and method groups have different
convertibility rules is rather unfortunate.