Question

是否可以覆盖内部方法的行为？

using System;

class TestClass
{
    public string Name { get { return this.ProtectedMethod(); } }

    protected string ProtectedMethod()
    {
        return InternalMethod();
    }

    string InternalMethod()
    {
        return "TestClass::InternalMethod()";
    }
}

class OverrideClassProgram : TestClass
{   // try to override the internal method ? (doesn't work)        
    string InternalMethod()
    {
        return "OverrideClassProgram::InternalMethod()";
    }

    static int Main(string[] args)
    {
        // TestClass::InternalMethod()
        Console.WriteLine(new TestClass().Name);
        // TestClass::InternalMethod() ?? are we just screwed?
        Console.WriteLine(new OverrideClassProgram().Name); 
        return (int)Console.ReadKey().Key;
    }
}

Answer 1

我觉得你这里有些困惑。有一个实际的关键字“内部”，这是你想要的吗？

internal string InternalMethod()
{
    return "TestClass::InternalMethod()";
}

但我认为你真正想要的是“虚拟”关键字。这允许您执行覆盖：父类

protected virtual string InternalMethod()
{
    return "TestClass::InternalMethod()";
}

儿童班

protected override string InternalMethod()
{
    return "TestProgram::InternalMethod()";
}

使用“new”关键字有效，但完全重新实现方法。即它破坏了多态性。

编辑：这是一个link。

Answer 2

在Java中，除非是静态/最终的，否则一切都是虚拟的。在C＃中，您必须显式将实例方法声明为虚拟，然后该方法不能是私有的。 This article解释了原因。

默认情况下，类的所有成员都是私有的，因此如果您不提供访问修饰符（当然不是私有），示例中的 InternalMethod（）方法是私有的，不能是虚拟的因此不能被覆盖。

您必须更改它的访问修饰符并将其标记为虚拟，并且在子类中必须覆盖它以使代码按您希望的方式工作。

Answer 3

这可能无法解答您的问题，只是为了增加一分钱。

Internal表示类型或成员只能在同一程序集中的文件中访问。它们对程序集是公开的，但实际上访问权限略低于public。

MSDN Access Modifiers，

内部访问的常见用途是基于组件的开发因为它启用一组组件没有私下合作暴露于其余的应用代码。例如，a 用于构建图形用户的框架接口可以提供控制和使用合作的表单类有内部访问权限的成员以来这些成员是内部的，他们是没有暴露于使用的代码框架

Answer 4

尝试使用override关键字... new关键字是调用类构造函数

Answer 5

当然，这是可能的，但为了覆盖方法，该方法必须是virtual或abstract，与任何其他可见性相同。

class Base
{
    internal virtual void Foo()
    {
        Console.WriteLine("Foo from Base");
    }
}

class Derived : Base
{
    internal override void Foo()
    {
        Console.WriteLine("Foo from Derived");
    }
}

当您使用new关键字时，它被称为method hiding，这不是一回事。如果我写这个：

class Base
{
    internal void Foo()
    {
        Console.WriteLine("Foo from Base");
    }
}

class Derived : Base
{
    internal new void Foo()
    {
        Console.WriteLine("Foo from Derived");
    }
}

static void Main()
{
    Base b = new Derived();
    b.Foo();
}

然后它会执行 Base Foo方法，而不是 Derived 。换句话说，它将打印Foo from Base。在第一种情况下，它仍然会执行 Derived 方法并打印Foo from Derived。

C＃问题中的继承 - 是否可能覆盖内部方法？

5 个答案: