“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，如果你使用override，它会输出true。

(基本代码取自Joseph Daigle)

所以，如果你在做真正的多态性，你应该总是OVERRIDE。唯一需要使用“new”的地方是当方法与基类版本没有任何关联时。

“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，如果你使用override，它会输出true。

(基本代码取自Joseph Daigle)

所以，如果你在做真正的多态性，你应该总是OVERRIDE。唯一需要使用“new”的地方是当方法与基类版本没有任何关联时。

我总是觉得这样的事情用图片更容易理解:

再一次，用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。

Virtual / override告诉编译器这两个方法是相关的，在某些情况下，当你认为你在调用第一个(虚拟)方法时，实际上应该调用第二个(被重写)方法。这是多态性的基础。

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

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

New告诉编译器，您正在向派生类添加与基类中的方法同名的方法，但它们之间没有关系。

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

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

(new SubClass()).NewBar()

将调用子类的NewBar()方法。

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。

Beyond just the technical details, I think using virtual/override communicates a lot of semantic information on the design. When you declare a method virtual, you indicate that you expect that implementing classes may want to provide their own, non-default implementations. Omitting this in a base class, likewise, declares the expectation that the default method ought to suffice for all implementing classes. Similarly, one can use abstract declarations to force implementing classes to provide their own implementation. Again, I think this communicates a lot about how the programmer expects the code to be used. If I were writing both the base and implementing classes and found myself using new I'd seriously rethink the decision not to make the method virtual in the parent and declare my intent specifically.