Как скрыть унаследованное свойство в классе без изменения унаследованного класса (базового класса)?

Я чувствую здесь запах кода. Я считаю, что вы должны наследовать базовый класс только в том случае, если вы реализуете все функции этого базового класса. То, что вы делаете, на самом деле не совсем правильно представляет принципы объектно-ориентированного программирования. Таким образом, если вы хотите наследовать от своей базы, вы должны реализовать Name, иначе у вас будет неправильное наследование. Ваш класс A должен быть вашим базовым классом, и ваш текущий базовый класс должен наследоваться от A, если вы этого хотите, а не наоборот.

Однако не отклоняйтесь слишком далеко от прямого вопроса. Если вы действительно хотели нарушить «правила» и хотите продолжить путь, который вы выбрали, вот как вы можете это сделать:

Соглашение состоит в том, чтобы реализовать свойство, но генерировать NotImplementedException при вызове этого свойства, хотя мне это тоже не нравится. Но это мое личное мнение, и оно не меняет того факта, что эта конвенция остается в силе.

Если вы пытаетесь сделать свойство устаревшим (и оно объявлено в базовом классе как виртуальное), вы можете либо использовать для него атрибут Obsolete:

[Obsolete("This property has been deprecated and should no longer be used.", true)]
public override string Name 
{ 
    get 
    { 
        return base.Name; 
    }
    set
    {
        base.Name = value;
    }
}

(Редактировать: Как указал Брайан в комментариях, второй параметр атрибута вызовет ошибку компиляции, если кто-то ссылается на свойство Name, поэтому он не сможет его использовать, даже если вы мы реализовали его в производном классе.)

Или, как я уже упоминал, используйте NotImplementedException:

public override string Name
{
    get
    {
        throw new NotImplementedException();
    }
    set
    {
        throw new NotImplementedException();
    }
}

Однако, если свойство не объявлено как виртуальное, вы можете использовать новое ключевое слово для его замены:

public new string Name
{
    get
    {
        throw new NotImplementedException();
    }
    set
    {
        throw new NotImplementedException();
    }
}

Вы по-прежнему можете использовать атрибут Obsolete так же, как если бы метод был переопределен, или вы можете создать исключение NotImplementedException, в зависимости от того, что вы выберете. Я бы, вероятно, использовал:

[Obsolete("Don't use this", true)]
public override string Name { get; set; }

or:

[Obsolete("Don't use this", true)]
public new string Name { get; set; }

В зависимости от того, был ли он объявлен виртуальным в базовом классе.

Хотя технически свойство не будет скрыто, один из способов категорически воспрепятствовать его использованию — добавить к нему следующие атрибуты:

[Browsable(false)]
[Bindable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[EditorBrowsable(EditorBrowsableState.Never)]

Это то, что System.Windows.Forms делает для элементов управления, свойства которых не подходят. Свойство Text, например, есть в Control, но оно не имеет смысла для каждого класса, наследуемого от Control. Итак, в MonthCalendar например, свойство Text выглядит так (согласно справочному онлайн-источнику):

[Browsable(false),
    EditorBrowsable(EditorBrowsableState.Never),
    Bindable(false), 
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public override string Text {
    get { return base.Text; }
    set { base.Text = value; }
}

• Возможность просмотра – отображается ли участник в окне свойств.
• EditorBrowsable – отображается ли участник в раскрывающемся списке Intellisense.

EditorBrowsable(false) не помешает вам ввести свойство, и если вы используете это свойство, ваш проект все равно будет компилироваться. Но поскольку это свойство не отображается в Intellisense, не будет так очевидно, что вы можете его использовать.

Просто спрячь это

 public class ClassBase
{
    public int ID { get; set; }
    public string Name { get; set; }
}
public class ClassA : ClassBase
{
    public int JustNumber { get; set; }
    private new string Name { get { return base.Name; } set { base.Name = value; } }
    public ClassA()
    {
        this.ID = 0;
        this.Name = string.Empty;
        this.JustNumber = 0;
    }
}

Примечание. Имя по-прежнему будет общедоступным членом ClassBase, учитывая ограничение не изменять базовый класс, и это невозможно остановить.

Зачем навязывать наследование, если в этом нет необходимости? Я думаю, что правильный способ сделать это — использовать has-a вместо is-a.

public class ClassBase
{
    public int ID { get; set; }

    public string Name { get; set; }
}

public class ClassA
{
    private ClassBase _base;

    public int ID { get { return this._base.ID; } }

    public string JustNumber { get; set; }

    public ClassA()
    {
        this._base = new ClassBase();
        this._base.ID = 0;
        this._base.Name = string.Empty;
        this.JustNumber = string.Empty;
    }
}

Я не думаю, что многие из тех, кто отвечает здесь, вообще не понимают наследования. Необходимо наследовать от базового класса и скрыть его некогда общедоступные переменные и функции. Например, скажем, у вас есть базовый двигатель, и вы хотите сделать новый двигатель с наддувом. Что ж, 99% движка вы будете использовать, но вы немного настроите его функциональность, чтобы он работал намного лучше, и все же есть некоторые функции, которые должны быть показаны только сделанным модификациям, а не конечному пользователю. Потому что мы все знаем, что каждый класс, который выпускает MS, на самом деле никогда не нуждается в каких-либо модификациях.

Помимо использования нового, чтобы просто переопределить функциональность, это одна из вещей, которые Microsoft в своей бесконечной мудрости….. о, я имею в виду ошибки, которые больше не считаются инструментом.

Лучший способ добиться этого сейчас — многоуровневое наследование.

public class classA 
{
}

public class B : A 
{} 

public class C : B 
{} 

Класс B выполняет всю вашу работу, а класс C предоставляет то, что вам нужно.

Я полностью согласен с тем, что свойства не следует удалять из базовых классов, но иногда производный класс может иметь другой, более подходящий способ ввода значений. В моем случае, например, я наследую от ItemsControl. Как мы все знаем, ItemsControl имеет свойство ItemsSource, но я хочу, чтобы мой элемент управления объединял данные из 2-х источников (например, Person и Location). Если бы мне нужно было, чтобы пользователь вводил данные с помощью ItemsSource, мне нужно было бы разделить, а затем снова объединить значения, поэтому я создал 2 свойства для ввода данных. Но вернемся к исходному вопросу: это оставляет ItemsSource, который я не хочу, чтобы пользователь использовал, потому что я «заменяю» его своими собственными свойствами. Мне нравятся идеи Browsable и EditorBrowsable, но это все равно не мешает пользователю их использовать. Основной момент здесь заключается в том, что наследование должно сохранять БОЛЬШИНСТВО свойств, но когда имеется большой сложный класс (особенно такой, в котором вы не можете изменить исходный код), переписывать все было бы очень неэффективно.

Вы не можете, в этом весь смысл наследования: подкласс должен предлагать все методы и свойства базового класса.

Вы можете изменить реализацию, чтобы генерировать исключение при вызове свойства (если бы оно было виртуальным)...

Вы можете использовать Browsable(false)

[Browsable( false )]
public override string Name
{
    get { return base.Name; }
    set { base.Name= value; }
}

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

Почему?

Хороший дизайн состоит в том, чтобы позволить базовому классу иметь общие свойства, которыми обладает определенная концепция (виртуальная или реальная). Пример: System.IO.Stream в C#.

В дальнейшем плохой дизайн увеличит стоимость обслуживания и сделает внедрение все труднее и труднее. Избегайте этого, насколько это возможно!

Основные правила, которыми я пользуюсь:

• Минимизируйте количество свойств и методов в базовом классе. Если вы не предполагаете использовать некоторые свойства или методы в классе, наследующем базовый класс; тогда не помещайте его в базовый класс. Если вы находитесь на стадии разработки проекта; всегда возвращайтесь к чертежной доске сейчас, а затем проверьте дизайн, потому что все меняется! Редизайн при необходимости. Когда ваш проект запущен, затраты на внесение изменений позже в дизайн возрастут!

  • Если вы используете базовый класс, реализованный третьей стороной, подумайте о том, чтобы «подняться» на один уровень вместо «переопределения» с помощью «NotImplementedException» или чего-то подобного. Если нет другого уровня, рассмотрите возможность разработки кода с нуля.

  • Всегда думайте о том, чтобы запечатать классы, которые вы не хотите, чтобы кто-либо мог наследовать. Это заставляет программистов «подниматься на один уровень вверх» в «иерархии наследования» и, таким образом, можно избежать «незавершенных концов», таких как «NotImplementedException».

Я знаю, что вопрос старый, но вы можете переопределить PostFilterProperties следующим образом:

 protected override void PostFilterProperties(System.Collections.IDictionary properties)
    {
        properties.Remove("AccessibleDescription");
        properties.Remove("AccessibleName");
        properties.Remove("AccessibleRole");
        properties.Remove("BackgroundImage");
        properties.Remove("BackgroundImageLayout");
        properties.Remove("BorderStyle");
        properties.Remove("Cursor");
        properties.Remove("RightToLeft");
        properties.Remove("UseWaitCursor");
        properties.Remove("AllowDrop");
        properties.Remove("AutoValidate");
        properties.Remove("ContextMenuStrip");
        properties.Remove("Enabled");
        properties.Remove("ImeMode");
        //properties.Remove("TabIndex"); // Don't remove this one or the designer will break
        properties.Remove("TabStop");
        //properties.Remove("Visible");
        properties.Remove("ApplicationSettings");
        properties.Remove("DataBindings");
        properties.Remove("Tag");
        properties.Remove("GenerateMember");
        properties.Remove("Locked");
        //properties.Remove("Modifiers");
        properties.Remove("CausesValidation");
        properties.Remove("Anchor");
        properties.Remove("AutoSize");
        properties.Remove("AutoSizeMode");
        //properties.Remove("Location");
        properties.Remove("Dock");
        properties.Remove("Margin");
        properties.Remove("MaximumSize");
        properties.Remove("MinimumSize");
        properties.Remove("Padding");
        //properties.Remove("Size");
        properties.Remove("DockPadding");
        properties.Remove("AutoScrollMargin");
        properties.Remove("AutoScrollMinSize");
        properties.Remove("AutoScroll");
        properties.Remove("ForeColor");
        //properties.Remove("BackColor");
        properties.Remove("Text");
        //properties.Remove("Font");
    }