C# - 关键字使用 virtual+override 与 new

Question

在基类型“virtual”中声明方法，然后使用“override”关键字在子类型中重写该方法与简单地使用“< code>new" 关键字在子类型中声明匹配方法时？

Answer 1

除了技术细节之外，我认为使用虚拟/覆盖可以传达有关设计的大量语义信息。 当您将方法声明为虚拟时，您表明您希望实现类可能想要提供它们自己的非默认实现。 同样，在基类中省略此方法，声明了默认方法应该足以满足所有实现类的期望。 类似地，可以使用抽象声明来强制实现类提供它们自己的实现。 同样，我认为这传达了很多关于程序员期望如何使用代码的信息。 如果我正在编写基类和实现类，并发现自己使用 new，我会认真重新考虑决定不在父类中使方法虚拟并明确声明我的意图。

Answer 2

“new”关键字不会覆盖，它表示一个与基类方法无关的新方法。

public class Foo
{
     public bool DoSomething() { return false; }
}

public class Bar : Foo
{
     public new bool DoSomething() { return true; }
}

public class Test
{
    public static void Main ()
    {
        Foo test = new Bar ();
        Console.WriteLine (test.DoSomething ());
    }
}

这将打印 false，如果您使用覆盖，它将打印 true。

（基本代码取自 Joseph Daigle）

因此，如果您正在执行真正的多态性，那么您应该始终覆盖。 唯一需要使用“new”的地方是当该方法与基类版本没有任何关系时。

Answer 3

new 关键字实际上创建了一个仅存在于该特定类型上的全新成员。

例如，

public class Foo
{
     public bool DoSomething() { return false; }
}

public class Bar : Foo
{
     public new bool DoSomething() { return true; }
}

两种类型都存在该方法。 当您使用反射并获取 Bar 类型的成员时，您实际上会发现两个名为 DoSomething() 的方法看起来完全相同。 通过使用 new，您可以有效地隐藏基类中的实现，以便当类从 Bar 派生时（在我的示例中），方法调用 base.DoSomething( ) 转到 Bar 而不是 Foo。

Answer 4

下面是一些代码，用于了解虚拟方法和非虚拟方法的行为差异：

class A
{
    public void foo()
    {
        Console.WriteLine("A::foo()");
    }
    public virtual void bar()
    {
        Console.WriteLine("A::bar()");
    }
}

class B : A
{
    public new void foo()
    {
        Console.WriteLine("B::foo()");
    }
    public override void bar()
    {
        Console.WriteLine("B::bar()");
    }
}

class Program
{
    static int Main(string[] args)
    {
        B b = new B();
        A a = b;
        a.foo(); // Prints A::foo
        b.foo(); // Prints B::foo
        a.bar(); // Prints B::bar
        b.bar(); // Prints B::bar
        return 0;
    }
}

Answer 5

虚拟/重写告诉编译器这两个方法是相关的，并且在某些情况下，当您认为正在调用第一个（虚拟）方法时，实际上调用第二个（重写）方法是正确的。 这是多态性的基础。

(new SubClass() as BaseClass).VirtualFoo()

将调用子类的重写 VirtualFoo() 方法。

new 告诉编译器您正在向派生类添加一个与基类中的方法同名的方法，但它们彼此没有关系。

(new SubClass() as BaseClass).NewBar()

将调用 BaseClass 的 NewBar() 方法，而：

(new SubClass()).NewBar()

将调用 SubClass 的 NewBar() 方法。

Answer 6

• new 关键字用于隐藏。 - 意味着您在运行时隐藏您的方法。 输出将基于基类方法。
• override 用于覆盖。 - 意味着您正在使用基类的引用调用派生类方法。 输出将基于派生类方法。

Answer 7

override关键字和new关键字的区别在于前者进行方法重写，后者进行方法隐藏。

查看以下链接以获取更多信息...

MSDN 和其他

Answer 8

我的解释版本来自使用属性来帮助理解差异。

override 很简单，对吧？ 基础类型覆盖父级的。

new 可能是一种误导（对我来说确实如此）。 使用属性更容易理解：

public class Foo
{
    public bool GetSomething => false;
}

public class Bar : Foo
{
    public new bool GetSomething => true;
}

public static void Main(string[] args)
{
    Foo foo = new Bar();
    Console.WriteLine(foo.GetSomething);

    Bar bar = new Bar();
    Console.WriteLine(bar.GetSomething);
}

使用调试器，您可以注意到 Foo foo 有 2 GetSomething 属性，因为它实际上有 2 个版本属性，Foo's 和 Bar's，并且为了知道使用哪一个，c#“挑选”当前类型的属性。

如果您想使用 Bar 的版本，则可以使用 override 或使用 Foo foo 代替。

Bar bar 只有 1，因为它需要 GetSomething 具有完全新行为。

Answer 9

不使用任何内容标记方法意味着：使用对象的编译类型而不是运行时类型（静态绑定）绑定此方法。

用virtual标记方法意味着：使用对象的运行时类型而不是编译时类型（动态绑定）来绑定该方法。

在派生类中用override 标记基类virtual 方法意味着：这是要使用对象的运行时类型进行绑定的方法（动态绑定）。

在派生类中用 new 标记基类virtual方法意味着：这是一个新方法，与基类中的同名方法没有关系。应使用对象的编译时类型进行绑定（静态绑定）。

在派生类中不标记基类虚拟方法意味着：该方法被标记为new（静态绑定）。

标记一个方法abstract意味着：这个方法是虚拟的，但我不会为它声明一个方法体，并且它的类也是抽象的（动态绑定）。

Answer 10

using System;  
using System.Text;  
  
namespace OverrideAndNew  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            BaseClass bc = new BaseClass();  
            DerivedClass dc = new DerivedClass();  
            BaseClass bcdc = new DerivedClass();  
  
            // The following two calls do what you would expect. They call  
            // the methods that are defined in BaseClass.  
            bc.Method1();  
            bc.Method2();  
            // Output:  
            // Base - Method1  
            // Base - Method2  
  
            // The following two calls do what you would expect. They call  
            // the methods that are defined in DerivedClass.  
            dc.Method1();  
            dc.Method2();  
            // Output:  
            // Derived - Method1  
            // Derived - Method2  
  
            // The following two calls produce different results, depending
            // on whether override (Method1) or new (Method2) is used.  
            bcdc.Method1();  
            bcdc.Method2();  
            // Output:  
            // Derived - Method1  
            // Base - Method2  
        }  
    }  
  
    class BaseClass  
    {  
        public virtual void Method1()  
        {  
            Console.WriteLine("Base - Method1");  
        }  
  
        public virtual void Method2()  
        {  
            Console.WriteLine("Base - Method2");  
        }  
    }  
  
    class DerivedClass : BaseClass  
    {  
        public override void Method1()  
        {  
            Console.WriteLine("Derived - Method1");  
        }  
  
        public new void Method2()  
        {  
            Console.WriteLine("Derived - Method2");  
        }  
    }  
}  

Answer 11

我总是发现这样的事情用图片更容易理解：

再次，采用 joseph daigle 的代码，

public class Foo
{
     public /*virtual*/ bool DoSomething() { return false; }
}

public class Bar : Foo
{
     public /*override or new*/ bool DoSomething() { return true; }
}

如果您然后像这样调用代码：

Foo a = new Bar();
a.DoSomething();

注意：重要的是我们的对象实际上是一个 Bar，但我们将其存储在 Foo 类型的变量中（这类似于强制转换它）

那么结果将如下所示，具体取决于是否您在声明类时使用了virtual/override 或new。