方法签名中的新关键字

在执行重构时，我最终创建了一个类似于以下示例的方法。为了简单起见，已更改数据类型。

我以前有这样的作业说明：

MyObject myVar = new MyObject();

偶然地将其重构为：

private static new MyObject CreateSomething()
{
  return new MyObject{"Something New"};
}

这是我剪切/粘贴错误的结果，但是new关键字in private static new有效并且可以编译。

问题：new关键字在方法签名中表示什么？我认为这是C＃3.0中引入的？

这override有何不同？

来自MSDN的新关键字参考：

MSDN参考

这是我在网上从Microsoft MVP中找到的一个很好的示例： 链接到原始

public class A
{
   public virtual void One();
   public void Two();
}

public class B : A
{
   public override void One();
   public new void Two();
}

B b = new B();
A a = b as A;

a.One(); // Calls implementation in B
a.Two(); // Calls implementation in A
b.One(); // Calls implementation in B
b.Two(); // Calls implementation in B

替代只能在非常特殊的情况下使用。从MSDN：

您不能覆盖非虚拟或静态方法。覆盖的基本方法必须是虚拟的，抽象的或覆盖的。

因此，需要使用“ new”关键字来允许您“覆盖”非虚拟和静态方法。

不，它实际上不是“新的”（对双关语）。它基本上用于“隐藏”方法。IE浏览器：

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

public class Derived : Base
{
   public new void Method(){}
}

如果您这样做，请执行以下操作：

Base b = new Derived();
b.Method();

Base中的方法将被调用，而不是派生方法。

一些更多信息：http : //www.akadia.com/services/dotnet_polymorphism.html

重新编辑：在我给出的示例中，如果要“覆盖”而不是“新”，则在调用b.Method（）时；由于多态性，将调用派生类的方法。

正如其他人解释的那样，它用于隐藏现有方法。这对于重写在父类中不是虚拟的方法很有用。

请记住，创建“新”成员不是多态的。如果将对象强制转换为基本类型，则它将不使用派生类型的成员。

如果您有基类：

public class BaseClass
{
    public void DoSomething() { }
}

然后是派生类：

public class DerivedType : BaseClass
{
    public new void DoSomething() {}

}

如果您声明的类型DerivedType然后进行转换，则该方法DoSomething()不是多态的，它将调用基类的方法，而不是派生的方法。

BaseClass t = new DerivedType();
t.DoSomething();// Calls the "DoSomething()" method of the base class.

从文档：

如果派生类中的方法前面带有new关键字，则该方法被定义为独立于基类中的方法。

实际上这意味着什么：

如果您从另一个类继承，并且您拥有一个共享相同签名的方法，则可以将其定义为“新”，从而使其独立于父类。这意味着，如果您引用“父”类，则将执行该实现；如果您引用了子类，则将执行该实现。

我个人尝试避免使用'new'关键字，因为它通常表示我的类层次结构错了，但是有时它可能很有用。一个地方是版本控制和向后兼容。

MSDN中有很多有关此的信息。

这意味着该方法用基类继承的相同名称替换方法。在您的情况下，您可能在基类中没有使用该名称的方法，这意味着new关键字完全多余。

长话短说-它不是必需的，它不会改变任何行为，并且纯粹出于可读性考虑。

这就是为什么在VS中您会看到一些混乱的原因，但是您的代码可以按预期的那样编译和运行得很好。

人们想知道，如果这是真的值得创建的new关键字时，它的意思是开发人员的承认“是的，我知道我躲在基方法，是的，我知道我没有做相关的任何事情virtual或overriden（多态性） -我真的很想创建它自己的方法”。

这对我来说有点奇怪，但可能仅是因为我来自Java背景，并且C#继承和Java：之间存在根本的区别：在中Java，方法默认情况下是虚拟的，除非由指定final。在中C#，除非由指定，否则方法默认为final / concrete virtual。

从MSDN：

使用new修饰符可显式隐藏从基类继承的成员。若要隐藏继承的成员，请在派生类中使用相同的名称对其进行声明，然后使用new修饰符对其进行修改。

小心这个陷阱。
您有一个在基类中实现的接口中定义的方法。然后，您创建一个隐藏该接口的方法的派生类，但不要专门将派生类声明为实现该接口。如果然后通过对接口的引用调用该方法，则将调用基类的方法。但是，如果派生类确实实现了该接口，则无论使用哪种引用类型，都将调用其方法。

interface IMethodToHide
{
    string MethodToHide();
}

class BaseWithMethodToHide : IMethodToHide
{
    public string MethodToHide()
    {
        return "BaseWithMethodToHide";
    }
}

class DerivedNotImplementingInterface   : BaseWithMethodToHide
{
    new public string MethodToHide()
    {
        return "DerivedNotImplementingInterface";
    }
}

class DerivedImplementingInterface : BaseWithMethodToHide, IMethodToHide
{
    new public string MethodToHide()
    {
        return "DerivedImplementingInterface";
    }
}

class Program
{
    static void Main()
    {
        var oNoI = new DerivedNotImplementingInterface();
        IMethodToHide ioNoI = new DerivedNotImplementingInterface();

        Console.WriteLine("reference to the object type DerivedNotImplementingInterface calls the method in the class " 
            + oNoI.MethodToHide());
        // calls DerivedNotImplementingInterface.MethodToHide()
        Console.WriteLine("reference to a DerivedNotImplementingInterface object via the interfce IMethodToHide calls the method in the class " 
            + ioNoI.MethodToHide());
        // calls BaseWithMethodToHide.MethodToHide()
        Console.ReadLine();

        var oI = new DerivedImplementingInterface();
        IMethodToHide ioI = new DerivedImplementingInterface();

        Console.WriteLine("reference to the object type DerivedImplementingInterface calls the method in the class " 
            + oI.MethodToHide());
        // calls DerivedImplementingInterface.MethodToHide()
        Console.WriteLine("reference to a DerivedImplementingInterface object via the interfce IMethodToHide calls the method in the class " 
            + ioI.MethodToHide());
        // calls DerivedImplementingInterface.MethodToHide()
        Console.ReadLine();

    }
}