34

在 C# 中，当您实现一个接口时，所有成员都是隐式公共的。如果我们可以指定可访问性修饰符（protected, internal，当然除了private）不是更好，还是应该只使用抽象类？

4

9 回答 9

36

如果接口是内部的，则其所有成员都将在程序集内部。如果嵌套接口受到保护，则只有外部类的子类可以访问该接口。

在其声明程序集之外的接口的内部成员将毫无意义，在其声明的外部类之外的接口的受保护成员也是如此。

接口的重点是描述实现类型和接口用户之间的契约。外部调用者不会关心也不应该关心实现，这是内部成员和受保护成员的用途。

对于基类调用的受保护成员，抽象类是在基类和继承自它们的类之间指定契约的方法。但是在这种情况下，实现细节通常是非常相关的，除非它是一个退化的纯抽象类（所有成员都是抽象的），在这种情况下受保护的成员是无用的。在这种情况下，使用接口并保存单个基类以供选择实现类型。

于 2008-08-20T08:28:02.147 回答
21

您可以通过在方法名称之前显式声明接口名称来隐藏接口的实现：

public interface IInterface {
    public void Method();
}

public class A : IInterface {
    public void IInterface.Method() {
        // Do something
    }
}

public class Program {
    public static void Main() {
        A o = new A();
        o.Method(); // Will not compile
        ((IInterface)o).Method(); // Will compile
    }
}
于 2008-08-20T08:32:47.080 回答
5

没有意义。接口是与您支持这些方法和属性的公众的合同。坚持使用抽象类。

于 2008-08-20T08:15:40.163 回答
5

这里的所有答案或多或少都说接口就是这样，它们是通用的公共规范。

这是讨论最多的线程，当这个问题浮现在我脑海中时，让我发布我在 SO 上找到的两个很好的答案。

这个答案给出了一个例子，说明在派生类中为接口成员使用非统一访问说明符是多么荒谬。代码总是比技术描述更好。

对我来说，强制公共接口成员最该死的事情是接口本身可以是程序集的内部，但它公开的成员必须是公共的。Jon Skeet 在这里解释说这是设计使然。

这就提出了一个问题，为什么接口的设计不是为成员提供非公共定义。这可以使合同灵活。这在编写不希望类的特定成员暴露在程序集之外的程序集时非常有用。我不知道为什么。

于 2012-09-24T20:06:18.657 回答
2

接口是所有实现类都遵守的契约。这意味着他们必须遵守全部或不遵守。

如果接口是公共的，那么该联系人的每个部分都必须是公共的，否则对于朋友/内部类来说意味着一个，而对其他所有部分来说都是不同的。

在接口上使用抽象基类或（如果可能且可行）内部扩展方法。

于 2008-08-20T08:41:37.387 回答
2

您可以隐藏几乎所有由外部程序集接口实现的代码。

interface IVehicle
{
    void Drive();
    void Steer();
    void UseHook();
}
abstract class Vehicle  // :IVehicle  // Try it and see!
{
    /// <summary>
    /// Consuming classes are not required to implement this method.
    /// </summary>
    protected virtual void Hook()
    {
        return;
    }
}
class Car : Vehicle, IVehicle
{
    protected override void Hook()  // you must use keyword "override"
    {
        Console.WriteLine(" Car.Hook(): Uses abstracted method.");
    }
    #region IVehicle Members

    public void Drive()
    {
        Console.WriteLine(" Car.Drive(): Uses a tires and a motor.");
    }

    public void Steer()
    {
        Console.WriteLine(" Car.Steer(): Uses a steering wheel.");
    }
    /// <summary>
    /// This code is duplicated in implementing classes.  Hmm.
    /// </summary>
    void IVehicle.UseHook()
    {
        this.Hook();
    }

    #endregion
}
class Airplane : Vehicle, IVehicle
{
    protected override void Hook()  // you must use keyword "override"
    {
        Console.WriteLine(" Airplane.Hook(): Uses abstracted method.");
    }
    #region IVehicle Members

    public void Drive()
    {
        Console.WriteLine(" Airplane.Drive(): Uses wings and a motor.");
    }

    public void Steer()
    {
        Console.WriteLine(" Airplane.Steer(): Uses a control stick.");
    }
    /// <summary>
    /// This code is duplicated in implementing classes.  Hmm.
    /// </summary>
    void IVehicle.UseHook()
    {
        this.Hook();
    }

    #endregion
}

这将测试代码。

class Program
{
    static void Main(string[] args)
    {
        Car car = new Car();
        IVehicle contract = (IVehicle)car;
        UseContract(contract);  // This line is identical...
        Airplane airplane = new Airplane();
        contract = (IVehicle)airplane;
        UseContract(contract);  // ...to the line above!
    }

    private static void UseContract(IVehicle contract)
    {
        // Try typing these 3 lines yourself, watch IDE behavior.
        contract.Drive();
        contract.Steer();
        contract.UseHook();
        Console.WriteLine("Press any key to continue...");
        Console.ReadLine();
    }
}
于 2008-10-30T19:04:16.830 回答
1

接口在其方法中没有访问修饰符，使它们对任何合适的访问修饰符开放。这有一个目的：它允许其他类型推断出哪些方法和属性可用于遵循接口的对象。为它们提供受保护/内部访问器会破坏接口的目的。

如果您坚持需要为方法提供访问修饰符，请将其保留在接口之外，或者如您所说，使用抽象类。

于 2008-08-20T08:16:33.203 回答
0

我熟悉 Java 而不是 C#，但是为什么你会想要一个接口中的私有成员呢？它不能有任何实现，并且对于实现类是不可见的，所以没有用。存在接口来指定行为。如果您需要默认行为而不是使用抽象类。

于 2008-08-20T08:17:08.430 回答
0

在我看来，这违反了封装。我必须实现一个公开的方法，然后我实现一个接口。我认为没有理由在实现接口的类中强制公开。（C＃）

于 2017-03-13T02:06:10.590 回答