новое ключевое слово в сигнатуре метода

Выполняя рефакторинг, я создал метод, подобный приведенному ниже. Тип данных был изменен для простоты.

Ранее у меня был такой оператор присваивания:

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

Повторите свое редактирование: в примере, который я привел, если вы должны «переопределить» вместо использования «new», то при вызове 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: In Java, методы являются виртуальными по умолчанию, если это не указано в final. В C#, методы по умолчанию являются окончательными / конкретными, если не указано иное 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();

    }
}