为什么我们在 C# 中重写方法时不能更改访问修饰符？

Question

在 C# 中，我们无法在重写基类方法时更改访问修饰符。 例如，

Class Base
{
   **protected** string foo()
   {
       return "Base";
   }
}

Class Derived : Base
{
   **public** override string foo()
   {
       return "Derived";
   }
}

这在 C# 中无效，它将给出编译时错误。

我想知道原因，为什么不允许。是否存在任何技术问题或者是否会导致访问限制方面不一致？？？

Answer 1

更改派生类型中方法的访问修饰符是没有意义的，这就是为什么不允许这样做的原因：

情况 1：使用更严格的访问覆盖

这种情况显然是不允许的，因为以下情况：

class Base
{
    public virtual void A() {}
}

class Derived: Base
{
    protected override void A()
}

现在我们可以说：

List<Base> list;
list.Add(new Derived());
list[0].A() //Runtime access exception

情况 2：使用更严格的覆盖进行覆盖限制较少的访问修饰符

有什么意义？隐藏方法就完成了。
显然，如果有人通过基类型调用，他们将无法访问派生类型中定义的新方法，但这与基类型的作者希望的方式一致，因此您没有“权利”更改它。如果您想要从派生类调用派生类的详细信息，在这种情况下，new 方法可以完美地工作。

编辑： 扩展案例 2

我在案例 2 中想说的是，如果您想更改可访问性，您已经有办法更改任何方法（虚拟或非虚拟）的可访问性。

考虑以下代码：

public class Base
{
    protected virtual string WhoAmI()
    {
        return "Base";
    }
}

public class Derived : Base
{
    public new virtual string WhoAmI()
    {
        return "Derived";
    }
}

public class AnotherDerived : Derived
{
    public override string WhoAmI()
    {
        return "AnotherDerived";
    }
}

使用 new 关键字，您已经有效地为您的 Derived 类创建了一个具有相同名称和签名的新虚拟方法。请注意，允许声明 new 方法 virtual，因此任何从 Derived 派生的类都将被允许重写它。

不允许的是让某人执行以下操作：

 Base newBaseObject = new Derived();
 newBaseObject.WhoAmI() //WhoAmI is not accessible.

但这事实与是否能够覆盖 WhoAmI() 无关。不管怎样，这种情况永远不会发生，因为 Base 没有声明 public WhoAmI()。

因此，在理论上的 C# 中，Derived.WhoAmI() 可以覆盖 Base.WhoAmI() ，这样做没有实际好处，因为您将永远无法调用虚拟无论如何，来自基类的方法，因此 new 选项已经满足您的要求。

我希望这能让事情变得更清楚。

Answer 2

好的，我在 Annotated C# 参考中找到了 Eric Lippert 的一个小注释：

重写的虚方法仍然被认为是引入它的类的方法。在某些情况下，重载解析规则更喜欢更多派生类型的成员...重写方法不会“移动”该方法在此层次结构中所属的位置。

因此，这是一个有意的规则，旨在防止“脆弱的基类”问题并提供更好的版本控制，即基类更改时出现的问题更少。

但请注意，它与安全性、类型安全或对象状态无关。

Answer 3

如果将可见性修饰符从限制性更强的修饰符更改为限制性更小的修饰符，则允许类客户端访问指定供内部使用的方法。本质上，您提供了一种改变类状态的方法，但这种方法可能不安全。

Answer 4

降低可见性是不可能的，因为如果 Base.Member 可见而 Derived.Member 不可见，那么就会破坏整个“Derived is a < OOP 中的“code>Base”概念。然而，增加可见性也许是不允许的，因为语言开发人员认为改变可见性在大多数情况下都是错误的。但是，您始终可以使用 new 关键字通过引入具有相同名称但行为不同的成员来隐藏基类成员。这个新成员属于派生类型的接口，因此当然您仍然可以通过转换为该基类型来访问该基类型的接口。根据您编写子类的方式，您的 new 成员可能会有效地提高基类属性的可见性，但请记住，基类的属性仍然可以直接访问（例如，您的子类的子类可以将 this 转换为 Base 并绕过您的属性）。

这里的问题是如何在子类中同时重写和new相同的命名成员（标识符）。这显然是不可能的。至少，我可以通过实验说 public new override string foo(){return "";} 不是这样的语法。但是，您可以通过使用两个子类获得相同的效果：

using System;
class Base
{
    protected virtual string foo()
    {
        return "Base";
    }
    public void ExhibitSubclassDependentBehavior()
    {
        Console.WriteLine("Hi, I am {0} and {1}.", GetType(), foo());
    }
}

abstract class AbstractDerived : Base
{
    protected virtual string AbstractFoo()
    {
        return base.foo();
    }
    protected override string foo()
    {
        return AbstractFoo();
    }
}

class Derived : AbstractDerived
{
    protected override string AbstractFoo()
    {
        return "Deprived";
    }
    public new string foo()
    {
        return AbstractFoo();
    }
}

static class Program
{
    public static void Main(string[] args)
    {
        var b = new Base();
        var d = new Derived();
        Base derivedAsBase = d;
        Console.Write(nameof(b) + " -> "); b.ExhibitSubclassDependentBehavior(); // "b -> Hi, I am Base and Base."
        Console.WriteLine(nameof(d) + " -> " + d.foo()); // "d -> Deprived"
        Console.Write(nameof(derivedAsBase) + " -> "); derivedAsBase.ExhibitSubclassDependentBehavior(); // "derivedAsBase -> Hi, I am Derived and Deprived."
    }
}

中间子类 (AbstractDerived) 使用 override 并引入一个新的、名称不同的成员，该子类和子类子类可以继续覆盖基类的成员，只要他们认为合适。子子类 (Derived) 使用 new 引入新的 API。由于每个子类化级别只能使用 new 或 override 与特定标识符一次，因此您需要两个级别的子类化才能有效地使用这两个级别在同一个标​​识符上。

因此，在某种程度上，您可以在重写方法的同时更改可见性——这只是一种痛苦，而且据我所知，没有任何语法可以仅通过一级继承来完成它。但是，您可能必须使用类似这样的技巧，具体取决于您尝试实现的接口以及您的基类的外观。也就是说，这可能是也可能不是您真正想要做的。但我仍然想知道为什么 C# 一开始就不支持这一点。 IOW，这个“答案”只是OP问题的重新表达和解决方法;-)。

Answer 5

您可以使派生类的访问权限少于基类的访问权限，但不能更多。否则，它将与基础的定义相矛盾，并暴露其组件超出预期。

Answer 6

原因很明显。对象的安全性和完整性。

在这个特定的示例中，如果外部实体开始修改根据基类保护的对象的属性，会发生什么情况。事情将会变得一团糟。针对所有/任何派生类必须符合的基类编写的客户端代码又如何呢？

Answer 7

如果它有不同的访问修饰符，你就不能再将它视为相同的方法。有点表明模型设计存在问题。

更好的问题是为什么要更改访问修饰符？

Answer 8

重写是一个术语，它使您能够更改或增强基类中方法的行为。重写使您可以控制为现有方法编写新逻辑。

更改基类的方法签名有点像编写一个新方法而不是覆盖现有方法。它与重写方法的目的相矛盾。这也许就是为什么在 C# 中重写方法时无法更改访问修饰符的原因。

Answer 9

我的理解是：

继承类时需要记住两件事。

• 父类公开的API/契约。
• 父类通过其成员/方法公开的功能。

当尝试决定是否继承一个类时，请独立考虑这两件事。

如果您只想通过类的成员方法公开功能，更好的方法是使用组合而不是继承。这样，您就可以定义类的 API/契约，并将您想要的任何成员、方法保留为公共、私有或受保护。

如果您希望您的类也符合您尝试继承的类的 API，那么就去继承该类。当您继承一个类时，您本质上同意您正在创建的类不会破坏基类保证的 API，因为您的类也是父类类型。保证基类的 API 不被破坏的一部分是不更改访问说明符。