Overloaded method calling overloaded method

Question

I have a method that I'm writing that is calling another overloaded method inside it. I'd like to only write one outer method, since the parameter to the outer method is being passed to the inner one. Is there a way to do this?

I tried using generics, but I don't know enough about this so it isn't working:

public void OuterMethod<T>(T parameter)
{
    InnerMethod(parameter); // InnerMethod accepts an int or a string
}

I know that I can do this:

public void OuterMethod(string parameter)
{
    InnerMethod(parameter);
}

public void OuterMethod(int parameter)
{
    InnerMethod(parameter);
}

But I'd rather do this the right way instead of copying/pasting code. What's the best way to accomplish this?

Answer 1

You can do this in C++ but not in C# (unless the inner method can also be generic instead of overloaded).

---

Alternatively (if you won't take 'no' for an answer), you can do a run-time switch on type, like for example ...

public void OuterMethod(object parameter)
{
    if (parameter is int)
        InnerMethod((int)parameter);
    else if (parameter is string)
        InnerMethod((string)parameter);
    else
        throw new SomeKindOfException();
}

... but obviously this is a run-time, not a compile-time check.

But I'd rather do this the right way instead of copying/pasting code.

You can also write software to write your outer methods (e.g. using System.CodeDom classes) instead of writing them by hand, but this is probably more trouble than it's worth.

Answer 2

Like the others said, you can't really do what you are trying to do and the option you stated in your question is the best bet.

You would actually have to convert the value if you use the generic. Otherwise you can downcast by accepting an Object as ChrisW suggests.

 public void OuterMethod<T>(T parameter) 
            {
                T temp = parameter;
                if (temp is string )
                    InnerMethod(Convert.ToString(temp));
                if (temp is int)
                    InnerMethod(Convert.ToInt32(temp));// InnerMethod accepts an int or a string
            }

Here is a link to the overview of Generics: http://msdn.microsoft.com/en-us/library/ms172193.aspx