¿Cómo ocultar una propiedad heredada en una clase sin modificar la clase heredada (clase base)?

Aunque técnicamente la propiedad no se ocultará, una forma de desalentar fuertemente su uso es ponerle atributos como estos:

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

Esto es lo que el Sistema.Windows.Forms hace para controles que tienen propiedades que no encajan. La propiedad Text, por ejemplo, está en Control, pero no tiene sentido en cada clase que hereda de Control. Así que en MonthCalendar, por ejemplo, aparece así (por reflector):

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

Navegable indica si el miembro aparece en la ventana de propiedades. EditorBrowsable indica si aparece en el menú desplegable Intellisense. Aún puede escribir la propiedad si EditorBrowsable está establecido en false, y aún se compilará, pero no será tan obvio que pueda usarla.

Solo escóndelo

 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;
    }
}

Nota: Name seguirá siendo un miembro público de ClassBase, dada la restricción de no cambiar la clase base, no hay forma de detenerlo.

¿Por qué forzar la herencia cuando no es necesario? Creo que la forma correcta de hacerlo es haciendo ha a en lugar de es-.

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;
    }
}

No creo que mucha de la gente que responde aquí entienda la herencia en absoluto. Hay una necesidad de heredar de una clase base y ocultar sus var y funciones una vez públicas. Por ejemplo, digamos que tienes un motor básico y quieres hacer un nuevo motor que esté sobrealimentado. Bueno, el 99% del motor que va a utilizar, pero va a ajustar un poco de su funcionalidad para que funcione mucho mejor y sin embargo todavía hay alguna funcionalidad que solo se debe mostrar a las modificaciones realizadas, no al usuario final. Porque todos sabemos que cada clase que EM pone realmente no necesita ninguna modificación.

Además de usar el nuevo para simplemente anular la funcionalidad es una de las cosas que Microsoft en su infinito wis..... oh, me refiero a los errores considerados una herramienta que ya no vale la pena.

La mejor manera de lograr esto ahora es la herencia multinivel.

public class classA 
{
}

public class B : A 
{} 

public class C : B 
{} 

La clase B hace todo su trabajo y la clase C expone lo que necesita expuesto.

Estoy completamente de acuerdo en que las propiedades no deben eliminarse de las clases base, pero a veces una clase derivada puede tener una forma diferente y más apropiada de ingresar los valores. En mi caso, por ejemplo, estoy heredando de ItemsControl. Como todos sabemos, ItemsControl tiene la propiedad ItemsSource, pero quiero que mi control combine datos de 2 fuentes (por ejemplo, Persona y Ubicación). Si tuviera que hacer que el usuario ingrese los datos usando ItemsSource, tendría que separar y luego recombinar el valores, así que he creado 2 propiedades para introducir los datos. Pero volviendo a la pregunta original, esto deja el ItemsSource, que no quiero que el usuario use porque lo estoy "reemplazando" con mis propias propiedades. Me gustan las ideas Navegables y EditorBrowsable, pero aún así no impide que el usuario lo use. El punto básico aquí es que la herencia debe mantener la MAYORÍA de las propiedades, pero cuando hay una clase compleja grande (especialmente aquellas donde no se puede modificar el código original), reescribir todo sería muy ineficiente.

No se puede, ese es el punto de la herencia: la subclase debe ofrecer todos los métodos y propiedades de la clase base.

Puede cambiar la implementación para lanzar una excepción cuando se invoca la propiedad (si fuera virtual)...

Creo que es un mal diseño si tienes que hacer esto, especialmente si eres capaz de diseñar el código desde cero.

¿Por qué?

Un buen diseño consiste en permitir que la clase base comparta las propiedades comunes que tiene un determinado concepto (virtual o real). Ejemplo: System. IO. Stream en C#.

Más adelante, el mal diseño aumentará el costo de mantenimiento y hará que la implementación sea cada vez más difícil. Evitar esto tanto como sea posible!

Reglas básicas que I uso:

• Minimizar el número de propiedades y métodos en la clase base. Si no espera usar algunas propiedades o métodos en una clase que hereda la clase base, entonces no lo coloque en la clase base. Si usted está en la etapa de desarrollo de un proyecto; siempre volver a la mesa de dibujo ahora y entonces para comprobar el diseño porque las cosas cambian! Rediseño cuando sea necesario. Cuando su proyecto está en marcha, los costos para cambiar las cosas más adelante en el diseño irán ¡arriba!

  • Si está utilizando una clase base implementada por una parte 3: rd, considere "subir" un nivel en lugar de "anular" con "NotImplementedException" o tal. Si no hay otro nivel, considere diseñar el código desde cero.

  • Siempre considere sellar las clases que no desea que nadie pueda heredarlo. Obliga a los codificadores a "subir un nivel" en la "jerarquía de herencia" y por lo tanto "cabos sueltos" como "NotImplementedException" puede ser evitar.

Sé que la pregunta es antigua, pero lo que puedes hacer es anular las propiedades PostFilter como esta:

 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");
    }