c# - C# 中的抽象显式接口实现

Question

我有这个 C# 代码：

abstract class MyList : IEnumerable<T>
{
    public abstract IEnumerator<T> GetEnumerator();

    //abstract IEnumerator IEnumerable.GetEnumerator();
}

照原样，我得到：

“类型”未实现接口成员“System.Collections.IEnumerable.GetEnumerator()”。

删除评论，我得到：

修饰符“抽象”对此项目无效

如何制作明确的实现抽象

score 37 · Accepted Answer

有趣 - 我不确定你能做到。但是，如果这是您的真实代码，您是否想通过调用泛型以外的任何GetEnumerator()方式实现非泛型？

我会这样做：

abstract class MyList<T> : IEnumerable<T>
{
    public abstract IEnumerator<T> GetEnumerator();

    IEnumerator IEnumerable.GetEnumerator() 
    {
        return GetEnumerator();
    }
}

这使您免于在每个派生类中实现它的繁琐——毫无疑问，这将使用相同的实现。

score 21 · Accepted Answer

虽然显式接口成员可能不是抽象（或虚拟）成员，但它可以根据抽象（或虚拟）成员¹来实现：

public abstract class Foo: IEnumerable {
    IEnumerator IEnumerable.GetEnumerator() { 
        return getEnumerator();    
    }

    protected abstract IEnumerator getEnumerator(); 
}

public class Foo<T>: Foo, IEnumerable<T> {
    private IEnumerable<T> ie;
    public Foo(IEnumerable<T> ie) {
        this.ie = ie;
    }

    public IEnumerator<T> GetEnumerator() {
        return ie.GetEnumerator();
    }

    protected override IEnumerator getEnumerator() {
        return GetEnumerator();
    }

    //explicit IEnumerable.GetEnumerator() is "inherited"
}

我发现在强类型的 ASP.NET MVC 3 部分视图中需要这样做，它不支持泛型类型定义模型（据我所知）。

score 1 · Accepted Answer

您实际上可以通过强制派生自抽象类的类来实现接口，并仍然允许它选择如何实现该接口 - 隐式或显式：

namespace Test
{
    public interface IBase<T>
    {
        void Foo();
    }

    public abstract class BaseClass<T> 
        where T : IBase<T>  // Forcing T to derive from IBase<T>
    { }

    public class Sample : BaseClass<Sample>, IBase<Sample>
    {
        void IBase<Sample>.Foo() { }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Sample sample = new Sample();

            // Error CS1061  'Sample' does not contain a definition for 'Foo' 
            // and no extension method 'Foo' accepting a first argument of type 'Sample' 
            // could be found(are you missing a using directive or an assembly reference ?)
            sample.Foo();

            (sample as IBase<Sample>).Foo(); // No Error
        }
    }
}

score 0 · Accepted Answer

我有一个稍微复杂的案例，我想要一个基类显式地实现非泛型接口，而派生类实现泛型接口。

接口：

public interface IIdentifiable<TKey> : IIdentifiable
{
    TKey Id { get; }
}

public interface IIdentifiable
{
    object Id { get; }
}

我通过在基类中声明一个抽象 getter 方法并让显式实现调用它来解决它：

public abstract class ModelBase : IIdentifiable
{
    object IIdentifiable.Id
    {
        get { return GetId();  }
    }

    protected abstract object GetId();
}

public class Product : ModelBase, IIdentifiable<int>
{
    public int ProductID { get; set; }

    public int Id
    {
        get { return ProductID; }
    }

    protected override object GetId()
    {
        return Id;
    }
}

请注意，基类没有Id它可以调用的类型化版本。

score 0 · Accepted Answer

似乎不可能做一个抽象的显式接口实现，但你可以做一个解决方法来摆脱错误，但仍然强制使用隐式的显式接口实现：

abstract class MyList : IEnumerable<T>
{
    public virtual IEnumerator<T> GetEnumerator() {
        (this as IEnumerable).GetEnumerator();
    }
}

但是，正如对上述问题的评论所指出的：

如果您选择让成员非抽象，编译器将允许没有（自己的）实现的子类......

c# - C# 中的抽象显式接口实现

5 回答 5

Related

Reference