Is it possible to overload a method based on another method?

Question

The question title might not be quite clear but here's what I want to do:

Say, I have a static class A. This class contains a static function called B. It has 10+ overloads. The function is pretty much basic in spite of so many overloads; it has nothing to do with other members of the class. I know I can access it from anywhere by importing the correct namespaces and using:

string bar = A.B("foo", true, 5) // Then do whatever with bar

Now, suppose I have another class C (Not in A). Now I want to make a method called D in C which behaves the same as A.B in all respects. I have tried:

public static class C {
    public static string D(string p1, bool p2, int p3) {
        return A.B(p1, p2, p3);
    }
}

But to overload this D method exactly like A.B, what do I have to do? Will I have to write all the separate overloads manually or is there a better way?

Answer 1

Will I have to write all the separate overloads manually

If you want to have an overload of D for each overload of B, then yes, you'll have to do exactly that.

Answer 2

Why not make your basic method an extension method with a generic type and then simply implement any type-specific logic in the single extension method?

Answer 3

This is a good example of the drawbacks of static methods.

If you can, convert these static methods to instance methods (perhaps of some new worker class, with a static factory method to return the instance, or use IOC). Then you'll have much more flexibility to use inheritance to avoid repeating code.

UPDATE

After some feedback, I had a think and it is possible, kind of. Use reflection to get the parameter lists for all the versions of B, and compare with the parameter list of D.

public static int D(params object[] paramArray)
{
    var paramTypes = paramArray.Select(x => x.GetType());
    var method = typeof(Static.A).GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy)
        .Where(m => m.Name == "B" && m.GetParameters().Select(x => x.ParameterType).SequenceEqual(paramTypes))
        .FirstOrDefault();
    if (method != null)
    {
        return (int)method.Invoke(null, paramArray);
    }
    throw new Exception("Overloaded method not found");
}

The downside of this approach is that there is no compile-time checking of parameters, no Intellisense, etc. I can't think of a way of getting round this without repeating the specification of each version of A.B(), like this:

    private static int GenericD(object[] paramArray, MethodBase caller)
    {
        var paramTypes = caller.GetParameters().Select(x => x.ParameterType);
        var method = typeof(Static.A).GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy)
            .Where(m => m.Name == "B" && m.GetParameters().Select(x => x.ParameterType).SequenceEqual(paramTypes))
            .FirstOrDefault();
        if (method != null)
        {
            return (int)method.Invoke(null, paramArray);
        }
        throw new Exception("Overloaded method not found");
    }

    public static int D(string p)
    {
        object[] paramArray = new object[] { p };
        return GenericD(paramArray, MethodInfo.GetCurrentMethod());
    }

    public static int D(string p, int x)
    {
        object[] paramArray = new object[] { p, x };
        return GenericD(paramArray, MethodInfo.GetCurrentMethod());
    }

In this solution, each version of D() is almost identical, but not quite. Ideally you would want some way of programmatically converting a method's parameter list into an object[], but there doesn't seem to be an easy way to do that.