Question: One more question from the [series](https://stackoverflow.com/questions/21403467/is-void-a-valid-return-value-for-a-function) "why does VisualStudio not support this code?"...

Given an overloaded function

```
private string ConfigQuery(string username) {
    return "A";
}
private string ConfigQuery(int configId) {
    return "B";
}

```

the following code is not possible:

```
public Config ConfigAPI(int id=0) {
    string s = ConfigQuery(id==0?User.Identity.Name:id);
}

```

but the code

```
public Config ConfigAPI(int id=0) {
    string s = (id==0?ConfigQuery(User.Identity.Name):ConfigQuery(id));
}

```

is. Is this reasonable behaviour? Then why would I use an overloaded function at all, instead of giving them more appropriate names like UserNameConfigQuery, ConfigIdConfigQuery?

Answer: 
Generally speaking, with a few exceptions such as the use of reflection, you are correct, there really isn't any "functionality" in overloading a method as opposed to creating a new method with a different name entirely. This is because, as has already been said, overload resolution is done at compile time (again, there are a few rare exceptions to this which should, generally speaking, be avoided) rather than at run time.

So you really *aren't* gaining anything, in terms of functionality, over giving each method a different name. It's mostly for convenience as a programmer, and to make it clear to users of your type that the method does the same thing, it just does it using one of several options.
Yes, this is reasonable behavior.

Remember that the overload to call is determined at [compile time vs. runtime](https://stackoverflow.com/q/846103/1810429). `id==0?` will not be evaluated until runtime of course.

You might still want to use overloads for:

* same operations for different types (e.g. `myString.Replace('1', '5')` vs. `myString.Replace("1", "5")`) instead of using generics
* optional/default params (e.g. `new Foo(bar)` vs. `new Foo(bar, baz)` or `myRegex.Replace("blah", "yada")` vs. `myRegex.Replace("blah", "yada", 2)`) instead of formal support that C# has added for optional and default parameters where they may make sense too

Also, IntelliSense, code documentation, and (formal or navigational) searches will help *a lot* less with differently-named methods that really do (nearly) the same thing, just differ on type or number of parameters. For example, consider finding and understanding the (near-)sameness of:

* `QueryConfig(string username)` and `QueryConfig(int configId)` using overloads *versus* `UserNameConfigQuery(string username)` and `ConfigIdConfigQuery(int configId)` using "more appropriate" names
* `Replace(string input, string replacement)` and `Replace(string input, string replacement, int count)` using overloads *versus* `CountRestrictedReplace(string input, string replacement, int count)` and `UnrestrictedReplace(string input, string replacement)` using "more appropriate" names