重载是向同一函数添加不同参数的唯一方法吗？

Question

I have 2 functions that does the same exact operation; since the underlying API has an overloaded fuction that accept either a string or an int.

Since I am using this function, I need to call the function either with a string or with an int. Is overloading the only way to do so? I replicate the code, beside the signature of the function; and it seems a waste of code.

public void taketwo(int value1, int value2)
{
    // Other operations happen here
    baseAPI.getvalues(value1, value2);
}

public void taketwo(string val1_str, string val2_str)
{
    // Other operations happen here
    baseAPI.getvalues(val1_str, val2_str);
}

I recall something about generic function; but I am not sure if that would apply in this case; I never used them in the past, and before dive in, I thought that it was worth to ask around first.

Answer 1

You could use dynamic typing here:

// I don't recommend you do this - see later
public void TakeTwo(dynamic value1, dynamic value2)
{
    baseAPI.GetValues(value1, value2);
}

The overload resolution for the call to GetValues will then be performed at execution time.

However:

• There's no compile-time checking that your call to TakeTwo will be valid
• It is less efficient (which may or may not be significant; the first point is more important in most cases)

You talk about replicating code, but in the example you've shown all the code is the method call. If there's other code in the method which is genuinely common, I'd recommend extracting that common code out and calling it in both overloads:

public void TakeTwo(int value1, int value2)
{
    CommonCode();
    baseAPI.GetValues(value1, value2);
}

public void TakeTwo(string value1, string value2)
{
    CommonCode();
    baseAPI.GetValues(value1, value2);
}

private void CommonCode()
{
    // Things you want to do in both methods
}

Answer 2

Do int and string parameters represent different concepts? If not, then you could code the implementation only once by calling 'string overload' from the 'int overload'

public void taketwo(int value1, int value2)
{
    taketwo(value1.ToString(), value2.ToString())
}

public void taketwo(string val1_str, string val2_str)
{
    // Other operations happen here
    baseAPI.getvalues(val1_str, val2_str);
}

This makes sense assuming there is more than just single API call in the methods.

Answer 3

Here is my version of code to handle above scenario. In my point of view it make sense to pass generic class instead of passing multiple parameter in function for flexibility.

What if the api version got changed and need to handle third type like decimal.

Below is the sample code which i though make it more flexible.

    public class MyValues<T>
    {
        public T value1 { get; set; }
        public T value2 { get; set; }
    }

    public void TakeTwo<T>(MyValues<T> myvalue)
    {
        baseAPI.getvalues(myvalue.value1, myvalue.value2);
    }

To call TakeTwo for typeof(string) we can use something like below.

    TakeTwo<string>(new MyValues<string>() { value1 = "string 1", value2 = "string 2" });

To call TakeTwo for typeof(string) we can use something like below.

    TakeTwo<int>(new MyValues<int>() { value1 = 123, value2 = 345 });

Does it make sense?

Answer 4

You could put the duplicate code - that you marked with // Other operations happen here - into its own method, if applicable. Obviously, this only would work, if this duplicate code doesn't make use of the passed in parameters.

---

Generic methods can't be used here, because generics are a compile time feature, not a runtime feature. What you could do would be to use dynamic . In that case, the overload resolution would happen at runtime. But it would have the disadvantage that you could also pass a double or Uri object and only at runtime you would get an exception, because no such overload exists for baseAPI.getvalues .

Code:

public void taketwo(dynamic value1, dynamic value2)
{
    // Other operations happen here
    baseAPI.getvalues(value1, value2);
}

Answer 5

Depending on your baseAPI design you could use generics:

public void taketwo<T>(T val1, T val2)
{
    // Other operations happen here
    baseAPI.getvalues<T>(val1, val2);
}

but that would require making your baseAPI.getvalues generic in the first place.

Answer 6

You can try to recieve an object (upcast), which means he will be able to send a string or int, and then with a simple if else you can send it to the correct function based on the value of that object.

public void taketwo(Object value1, Object value2) { 

// Other operations happen here 

If (check if value1 is a number) {
  baseAPI.getvalues(value1, value2); 
} else {
  baseAPI.getvalues(val1_str, val2_str);
}

Answer 7

Well, technically you can combine all this parameters into one method and set them having default parameter null .

public void taketwo(int? value1 = null, int? value2 = null, 
                    string val1_str = null, string val2_str = null)
{
    if (value1 != null)
       baseAPI.getvalues(value1.Value, value2.Value);
    else if (val1_str != null)
       baseAPI.getvalues(val1_str, val2_str);
}

So you can call it as taketwo(1, 2) as well as taketwo(val1_str:"str1", val2_str:"str2") since all parameters has default values.

Will it be more convinient or not - it's up to you. Personally I'd prefer method overloading rather than combining all possible parameters into one method.