在特殊情况下解决通用和非通用IList扩展方法之间的歧义调用

Question

I have an extension function called RemoveWhere . It simply accepts a predicate and removes items from a list which satisfy the condition. I removed the implementation for clarity.

public static IList<object> RemoveWhere(this IList list, Func<object, bool> predicate, int offset = 0)
{
    ...
}

public static IList<T> RemoveWhere<T>(this IList<T> list, Func<T, bool> predicate, int offset = 0)
{
    ...
}

I needed this method for generic IList<T> and non-generic IList as well, because we have several scenarios where only a non-generic interface is available.

However, when I have a specific List<T> instance, I get an ambiguous call compile-time error because it implements both the generic and non-generic interface.

How could I resolve it without renaming one of the methods?

UPDATE

I'm looking for a general solution which would apply to all collections which possibly implement both interfaces. I currently use Visual Studio 2013 and targeting .NET 4.

UPDATE 2

It turns out that the ambiguous call issue only appears when I don't reference any member of T directly in the predicate. Example here.

class Person {}
class SpecialPerson : Person {}

var list = new List<Person>();
// this resolves to the generic version
list.RemoveWhere(e => e.Name.Contains("Peter");
// this gives ambiguous call compiler error
list.RemoveWhere(e => e is SpecialPerson);

Answer 1

If have tested this code and it calls the correct Extension for the different type:

class Program
{
    static void Main(string[] args)
    {
        var genericList = new List<String>() {"a", "b"};
        var listImplementation = new MyList();

        var resultGeneric = genericList.RemoveWhere(x => x.Contains("s"));
        var resultImplemented = listImplementation.RemoveWhere(x => x.Equals(1));
    }
}

class MyList : IList
{
   ...
}

public static class JTest
{
    public static IList RemoveWhere(this IList list, Func<object, bool> predicate, int offset = 0)
    {
        return list;
    }

    public static IList<T> RemoveWhere<T>(this IList<T> list, Func<T, bool> predicate, int offset = 0)
    {
        return list;
    }
}

Answer 2

You could introduce a third overload(!) which calls the right one, as in:

public static IList<T> RemoveWhere<T>(this List<T> list, Func<T, bool> predicate, int offset = 0)
{
  return ((IList<T>)list).RemoveWhere(prdeicate, offset);
}

Answer 3

For this special case when I don't reference any member of T in the predicate I ended up adding the generic parameter to the call, helping out the compiler.

class Person {}
class SpecialPerson : Person {}

var list = new List<Person>();
// this resolves to the generic version
list.RemoveWhere(e => e.Name.Contains("Peter");
// this gives ambiguous call compiler error
list.RemoveWhere(e => e is SpecialPerson);
// if I help the compiler it resolves correctly
list.RemoveWhere<Person>(e => e is SpecialPerson);