接口扩展方法在实现类上不可见

Question

I've defined a "type translator" interface (please don't mention AutoMapper, not relevant) as follows:

public interface ITranslator<TSource, TResult>
{
    TResult Translate(TSource source);
}

And for convenience sake, I've defined an extension method for enumerables:

public static class ExtendITranslator
{
    public static IEnumerable<TResult> TranslateSet<TSource, TResult>(
        this ITranslator<TSource, TResult> self, 
        IEnumerable<TSource> sourceSet)
    {
        return sourceSet.Select(o => self.Translate(o));
    }
}

And then I define the implementation as so:

public class Translator :
    ITranslator<Report, Report.ReportServiceModel>,
    ITranslator<Report.ReportServiceModel, Report>
{
    public Report Translate(Report.ReportServiceModel source)
    {
        throw new NotImplementedException();
    }

    public Report.ReportServiceModel Translate(Report source)
    {
        throw new NotImplementedException();
    }
}

The problem is, when I work with the Translator implementation, it doesn't expose TranslateSet as an extension method, unless I cast:

Translator translator = new Translator();

// not exposed
translator.TranslateSet(/* ... */);

// exposed with a cast
(translator as ITranslator<Report, Report.ReportServiceModel>).TranslateSet(/* ... */);

Why is this? Other class implementations expose extension methods defined for the interfaces they implement:

public interface IUpdater<TModel> where TModel : class, new()
{
    bool Update(TModel model);
}

public static class ExtendIRepositoryWriter
{
    public static int UpdateSet<TModel>(
        this IRepositoryWriter<TModel> self,
        IEnumerable<TModel> modelSet) where TModel : class, new()
    {
        return modelSet.Count(o => self.Update(o));
    }
}

public class ReportUpdater : IUpdater<Report>
{
    public bool Update(Report model)
    {
        throw new NotImplementedException();
    }
}

In this case, the UpdateSet extension method is available on instances of ReportUpdater :

ReportUpdater reportUpdater = new ReportUpdater();

// all good!
reportUpdater.UpdateSet(/* ... */);

Can anyone shed some light on this? Did I fat-finger a typo or something? (It is Friday night after all)

Answer 1

Your other working example is actually misleading and is not a true apples-to-apples comparison.

Due to a single generic argument, the compiler is able to infer the type since you are invoking on an instance of that type.

This is not the case with the extension giving you trouble, since there are two type arguments. You can resolve this by assigning the concrete type to an interface declaring the types.

ITranslator<Report, Report.ReportServiceModel> translator = new Translator();

translator.TranslateSet(/* ... */);