Почему нам нужно новое ключевое слово и почему поведение по умолчанию состоит в том, чтобы скрыть и не переопределить?

Если переопределение было по умолчанию без указания ключевого слова override , вы могли случайно переопределить какой-либо метод вашей базы только из-за равенства имен.

Стратегия компилятора .Net состоит в том, чтобы на всякий случай выдавать предупреждения, если что-то может пойти не так, поэтому в этом случае, если переопределение было по умолчанию, должно быть предупреждение для каждого метода переопределения - что-то вроде «предупреждение: проверьте, если вы действительно хотите переопределить ».

Я предполагаю, что в основном это связано с множественным наследованием интерфейсов. При использовании незаметных интерфейсов вполне возможно, что два разных интерфейса будут использовать одну и ту же сигнатуру метода. Разрешение использования ключевого слова new позволит вам создавать эти разные реализации с одним классом, вместо того, чтобы создавать два разных класса.

Обновлено ... Эрик дал мне идею, как улучшить этот пример.

public interface IAction1
{
    int DoWork();
}
public interface IAction2
{
    string DoWork();
}

public class MyBase : IAction1
{
    public int DoWork() { return 0; }
}
public class MyClass : MyBase, IAction2
{
    public new string DoWork() { return "Hi"; }
}

class Program
{
    static void Main(string[] args)
    {
        var myClass = new MyClass();
        var ret0 = myClass.DoWork(); //Hi
        var ret1 = ((IAction1)myClass).DoWork(); //0
        var ret2 = ((IAction2)myClass).DoWork(); //Hi
        var ret3 = ((MyBase)myClass).DoWork(); //0
        var ret4 = ((MyClass)myClass).DoWork(); //Hi
    }
}

В C# члены по умолчанию запечатаны, что означает, что вы не можете их переопределить (если они не помечены ключевыми словами virtual или abstract) и это сделано по причинам производительности. Модификатор new используется для явного скрытия наследуемого члена.

Если методу в производном классе предшествует ключевое слово new, метод определяется как независимый от метода в базовом классе

Однако, если вы не укажете ни один из новых или переопределяет, результирующий вывод будет таким же, как если бы вы указали новый, но вы получите предупреждение компилятора (поскольку вы можете не знать, что скрываете метод в методе базового класса, или действительно, возможно, вы хотели его переопределить , и просто забыл включить ключевое слово).

Таким образом, это помогает вам избежать ошибок и ясно показывает, что вы хотите сделать, и делает код более читаемым, чтобы вы могли легко понять ваш код.

Вы правы, что ключевое слово new явно скрывает член из базового класса, так что вызывающие абоненты в конечном итоге используют член в вашем подклассе, а не в версии суперкласса. Как также упоминается в этом сообщении в блоге, вы также можете неявно сделать это.

Это отличается от переопределения члена базового класса; для этого член базового класса должен быть помечен как абстрактный или виртуальный. Таким образом, не каждый член базового класса можно переопределить. Предположим, вы создаете подкласс класса из чужой сборки, и у вас нет доступа или вы не хотите возвращаться и модифицировать этот код, чтобы сделать членов виртуальными. Без нового ключевого слова вы бы застряли.

Вы можете поспорить, что лучше иметь ключевое слово и быть явным (мое мнение) или просто делать это неявно.

Как уже отмечалось, скрытие метода / свойства позволяет изменять элементы метода или свойства, которые иначе нельзя было бы легко изменить. Одна из ситуаций, когда это может быть полезно, - это разрешение унаследованному классу иметь свойства чтения и записи, которые доступны только для чтения в базовом классе. Например, предположим, что базовый класс имеет набор свойств, доступных только для чтения, которые называются Value1-Value40 (конечно, для реального класса имена будут лучше). Запечатанный потомок этого класса имеет конструктор, который принимает объект базового класса и копирует оттуда значения; после этого класс не позволяет их менять. Другой наследуемый потомок объявляет свойства чтения-записи под названием Value1-Value40, которые при чтении ведут себя так же, как версии базового класса, но при записи позволяют записывать значения. Чистый эффект будет заключаться в том, что код, которому нужен экземпляр базового класса, который, как он знает, никогда не изменится, может создать новый объект класса только для чтения, который может копировать данные из переданного объекта, не беспокоясь о том, что этот объект доступен только для чтения или чтения-записи.

В этом подходе есть одно неудобство - возможно, кто-то может мне помочь - это то, что я не знаю способа как затенять, так и отменять конкретное свойство в одном классе. Допускает ли это какой-либо из языков CLR (я использую vb 2005)? Было бы полезно, если бы объект базового класса и его свойства могли быть абстрактными, но это потребовало бы, чтобы промежуточный класс переопределил свойства Value1 до Value40, прежде чем класс-потомок сможет их затенять.

Стоит отметить, что эффект only new в этом контексте заключается в подавлении предупреждения. Семантика без изменений.

Итак, один ответ: нам нужно new , чтобы сообщить компилятору, что скрытие намеренно , и избавиться от предупреждения.

Следующий вопрос: если вы не хотите / не можете переопределить метод, зачем вам вводить другой метод с тем же именем? Потому что сокрытие - это, по сути, конфликт имен. И вы, конечно, в большинстве случаев этого избегаете.

Единственная веская причина для намеренного сокрытия, которую я могу придумать, - это когда имя навязывается вам интерфейсом.