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: 
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
You did not post the error you got, but by the look of it the failure has nothing to do with overloading.

The error is because the ternary operator `?` cannot get a string and int arguments, they need to be of the same type or with an implicit cast between them.

[this](https://stackoverflow.com/questions/18260528/type-of-conditional-expression-cannot-be-determined-because-there-is-no-implicit) post explains it rather well.

**Edit:**  

From the spec, you can understand the reason for the failure:

> 
> If x has type X and y has type Y then:
> 
> 
> * If an implicit conversion (§6.1) exists from X to Y, but not from Y to X, then Y is the type of the conditional expression.
> * If an implicit conversion (§6.1) exists from Y to X, but not from X to Y, then X is the type of the conditional expression.
> * Otherwise, no expression type can be determined, and a compile-time error occurs.
> 
> 
>