How to remove ambiguous method call in c#

Question

Here I have a simple scenario with two methods where I get an ambiguous invocation from one another:

This is a my code:

public IEnumerable<JobsViewModel> GetJobsViewModels(Guid vesselId, int status, Func<JobsNoSubsYpdcResult, bool> predicate = null)
    => predicate == null
        ? Mapper.Map<IEnumerable<JobsViewModel>>(_procedureService.Tech_GetJobsNoSubsYPDC(vesselId, status))
        : Mapper.Map<IEnumerable<JobsViewModel>>(_procedureService.Tech_GetJobsNoSubsYPDC(vesselId, status).Where(predicate));

public IEnumerable<JobsViewModel> GetJobsViewModels(Guid vesselId, int status, Func<JobsViewModel, bool> predicate = null)
    => predicate == null
        ? GetJobsViewModels(vesselId, status)
        : GetJobsViewModels(vesselId, status).Where(predicate);

I dont like changing the names of methods but from the second one I get the error message:

Ambiguous Invocation

I would like to call first one from second one like I am trying to do, does anybody know how can I do this without changing the method names otherwise I am supposed to change them ?

Answer 1

The best way to handle this is to not have two overloads that are ambiguous, that way you don't need to remember how to special-case this everywhere you call them.

Since your second overload calls the first I would say the most logical cause of action would be to remove the default parameter value for that delegate:

public IEnumerable<JobsViewModel> GetJobsViewModels(Guid vesselId, int status, Func<JobsViewModel, bool> predicate)
    => predicate == null
        ? GetJobsViewModels(vesselId, status)
        : GetJobsViewModels(vesselId, status).Where(predicate);

---

You should also reason about the ability to call this method specifying the delegate parameter, but explicitly specifying null. If this is not really meant to be possible anyway (ie. the first part of the ternary expression is not really going to be used) then I would simplify the entire method:

public IEnumerable<JobsViewModel> GetJobsViewModels(Guid vesselId, int status, Func<JobsViewModel, bool> predicate)
    => GetJobsViewModels(vesselId, status).Where(predicate);

---

Now, having said all that I don't really see the point of this second method anyway, as on the outside I could simply tuck on a .Where(...) filter anyway. Since the method doesn't do anything clever with this predicate, like passing it on and doing it on a lower level, or optimizing the way it fetches data, then this is really just syntactic sugar.

However, that's just my opinion, and I admittedly don't know how all of this is going to be used. My real answer is the first part though, you really should avoid declaring ambiguous methods.

---

Also see this question: Breaking change in method overload resolution in C# 6 - explanation?.

Overload resolution changed when Roslyn entered the scene and they decided to document the change and make it breaking instead of reintroducing the old "bug".

Answer 2

You need to provide the optional argument and make its type clear to the compiler, even if the value is null:

GetJobsViewModels(vesselId, status, (Func<JobsNoSubsYpdcResult, bool>)null)

---

EDIT: In the particular case presented by the OP, Lasse's solution is preferable.

The solution shown in this answer here, on the other hand, can be applied generally, also when disambiguating overloads where the other overload does not have an optional parameter that can be made non-optional (e.g. when invoking some of the ArgumentNullException constructors).

Answer 3

The only way to do this would be to fill in the optional parameter with a value of the appropriate type, so that the compiler knows which overload to pick. For example:

public IEnumerable<JobsViewModel> GetJobsViewModels(
    Guid vesselId,
    int status,
    Func<JobsViewModel, bool> predicate = null)
{
    // We're never filtering by JobsNoSubsYpdcResult, but this
    // satisfies overload resolution
    Func<JobsNoSubsYpdcResult, bool> resultPredicate = null;
    return predicate == null
        ? GetJobsViewModels(vesselId, status, resultPredicate)
        : GetJobsViewModels(vesselId, status, resultPredicate).Where(predicate);
}

Or to avoid repetition:

public IEnumerable<JobsViewModel> GetJobsViewModels(
    Guid vesselId,
    int status,
    Func<JobsViewModel, bool> predicate = null)
{
    // We're never filtering by JobsNoSubsYpdcResult, but this
    // satisfies overload resolution
    Func<JobsNoSubsYpdcResult, bool> resultPredicate = null;
    var allResults = GetJobsViewModels(vesselId, status, resultPredicate);
    return predicate == null
        ? allResults : allResults.Where(predicate);
}

Or to avoid even more repetition, introduce your own extension method:

public static IEnumerable<T> OptionalWhere<T>(
    this IEnumerable<T> source,
    Func<T, bool> predicate) =>
    predicate == null ? source : source.Where(predicate);

Then you can rewrite both methods to use that:

public IEnumerable<JobsViewModel> GetJobsViewModels(Guid vesselId, int status, Func<JobsNoSubsYpdcResult, bool> predicate = null) =>
    Mapper.Map<IEnumerable<JobsViewModel>>(_procedureService.Tech_GetJobsNoSubsYPDC(vesselId, status))
        .OptionalWhere(predicate);

public IEnumerable<JobsViewModel> GetJobsViewModels(
    Guid vesselId,
    int status,
    Func<JobsViewModel, bool> predicate = null)
{
    // We're never filtering by JobsNoSubsYpdcResult, but this
    // satisfies overload resolution
    Func<JobsNoSubsYpdcResult, bool> resultPredicate = null;
    return GetJobsViewModels(vesselId, status, resultPredicate)
        .OptionalWhere(predicate);
}

(You can use an expression-bodied method if you're happy to cast null to Func<JobsNoSubsYpdcResult, bool> or use a static field for that.)

Answer 4

If you really want what you say you want, you need to pass the proper predicate argument, e.g. GetJobsViewModels(vesselId, status, new Func<JobsNoSubsYpdcResult, bool>( x => true ));