继承集合类并实现枚举接口时，IEnumerable扩展方法不可用问题

The core issue here ties into how C# handles explicit interface implementation and enumerable type resolution. Let’s break this down clearly and walk through solutions:

Root Cause #

Your TestList inherits from ObservableCollection<TestClass> (which already implements IEnumerable<TestClass>) and explicitly implements IEnumerable<ITestInterface>. When you implement an interface explicitly, its members (like GetEnumerator()) aren’t directly visible on class instances—you have to cast the object to that interface to access them.

LINQ extension methods (like Where, Select) rely on resolving the correct IEnumerable<T> type at compile time. Since the default enumerable exposed by TestList is IEnumerable<TestClass> from the base class, the compiler won’t automatically pick up your explicit IEnumerable<ITestInterface> implementation unless you tell it to.

Solution 1: Quick Fix with Explicit Cast #

The simplest way to use LINQ with ITestInterface members is to cast your TestList instance to IEnumerable<ITestInterface>:

var myList = new TestList();

// Filter using ITestInterface properties/methods
var filteredItems = ((IEnumerable<ITestInterface>)myList)
    .Where(ti => ti.IsValid())
    .ToList();

This directly tells the compiler to use your explicit interface implementation instead of the base ObservableCollection’s enumerable.

Solution 2: Implicitly Implement IEnumerable #

To avoid casting every time, re-implement IEnumerable<ITestInterface> implicitly by adding a public GetEnumerator() method. This makes the interface’s enumerable behavior directly accessible on your TestList instances:

public class TestList : ObservableCollection<TestClass>, 
                        IList<ITestInterface>, 
                        ICollection<ITestInterface>, 
                        IEnumerable<ITestInterface>
{
    // Implicit implementation for IEnumerable<ITestInterface>
    public new IEnumerator<ITestInterface> GetEnumerator()
    {
        // Safe to cast since TestClass implements ITestInterface
        foreach (TestClass item in this)
        {
            yield return item;
        }
    }

    // Required for non-generic IEnumerable compliance
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

    // Example implementation for other interface members
    public void Add(ITestInterface item)
    {
        if (item is not TestClass testItem)
        {
            throw new ArgumentException("Item must be of type TestClass", nameof(item));
        }
        base.Add(testItem);
    }

    // Add implementations for IList/ICollection members like Insert, Remove, etc.
}

Now you can use LINQ directly without casting:

var myList = new TestList();
var filteredItems = myList.Where(ti => ti.SomeInterfaceProperty == "target").ToList();

Solution 3: Explicitly Specify LINQ Generic Type #

If you want to keep the explicit interface implementation but skip casting, specify the generic type parameter in your LINQ call:

var myList = new TestList();
var filteredItems = myList.Where<ITestInterface>(ti => ti.MeetsCriteria()).ToList();

This forces the compiler to use the IEnumerable<ITestInterface> overload of the LINQ method.

Key Notes #

• Since TestClass implements ITestInterface, all type conversions here are safe and implicit—no invalid cast risks.
• For operations using TestClass-specific members, you can still use the base IEnumerable<TestClass> implementation directly (no casting needed).

内容的提问来源于stack exchange，提问作者Alex