Cacher les membres hérités

Les remplacer comme Michael Suggère ci-dessus et pour empêcher les gens d'utiliser le remplacé (sp?) les méthodes, les marquer comme obsolète:

[Obsolete("These are not supported in this class.", true)]
public override  void dontcallmeanymore()
{
}

Si le deuxième paramètre est défini sur true, une erreur de compilation sera généré si quelqu'un essaie d'appeler la méthode et de la chaîne dans le premier paramètre est le message. Si parm2 est faux seulement un avertissement du compilateur sera généré.

Une chose que vous pouvez faire est de contenir de l'objet plutôt que de s'étendre de l'autre classe. Cela vous donnera une plus grande souplesse en termes d'exposer ce que vous souhaitez exposer, mais si vous avez absolument besoin de l'objet de ce type, il n'est pas la solution idéale (sinon, vous pourriez vous exposer l'objet d'un getter).

Ainsi:

public class MyClass : BaseClass
{
    //Your stuff here
}

Devient:

public class MyClass
{
    private BaseClass baseClass;

    public void ExposeThisMethod()
    {
        baseClass.ExposeThisMethod();
    }
}

Ou:

public class MyClass
{
    private BaseClass baseClass;

    public BaseClass BaseClass
    {
        get
        {
            return baseClass;
        }
    }
}

Je sais qu'il y a eu plusieurs réponses à cela, et il est assez vieux maintenant, mais la méthode la plus simple pour ce faire est juste de les déclarer comme new private.

Prenons un exemple, je suis en train de travailler, où j'ai une API qui met à la disposition de chaque méthode dans une 3e partie de la DLL. Je dois prendre leurs méthodes, mais je veux utiliser un .Nets de la propriété, au lieu d'un "getThisValue" et "setThisValue" la méthode. Donc, j'ai créer une deuxième classe, héritent de la première, faire une propriété qui utilise les méthodes get et set, puis remplacer l'original méthodes get et set comme privé. Ils sont toujours disponibles à tous ceux qui veulent construire quelque chose de différent sur eux, mais si ils veulent juste utiliser le moteur je suis en train de construire, puis ils seront en mesure d'utiliser les propriétés au lieu de méthodes.

À l'aide de la double méthode de classe, se débarrasser de toutes les restrictions sur l'impossibilité d'utiliser les new déclaration de cacher les membres. Vous ne pouvez pas utiliser override si les membres sont marqués comme virtuel.

public class APIClass
{
    private static const string DllName = "external.dll";

    [DllImport(DllName)]
    public extern unsafe uint external_setSomething(int x, uint y);

    [DllImport(DllName)]
    public extern unsafe uint external_getSomething(int x, uint* y);

    public enum valueEnum
    {
        On = 0x01000000;
        Off = 0x00000000;
        OnWithOptions = 0x01010000;
        OffWithOptions = 0x00010000;
    }
}

public class APIUsageClass : APIClass
{
    public int Identifier;
    private APIClass m_internalInstance = new APIClass();

    public valueEnum Something
    {
        get
        {
            unsafe
            {
                valueEnum y;
                fixed (valueEnum* yPtr = &y)
                {
                    m_internalInstance.external_getSomething(Identifier, yPtr);
                }
                return y;
            }
        }
        set
        {
            m_internalInstance.external_setSomething(Identifier, value);
        }
    }

    new private uint external_setSomething(int x, float y) { return 0; }
    new private unsafe uint external_getSomething(int x, float* y) { return 0; }
}

Maintenant valueEnum est disponible pour les deux classes, mais seulement la propriété est visible dans le APIUsageClass classe. Le APIClass classe est toujours disponible pour les personnes qui veulent prolonger l'origine de l'API ou de l'utiliser d'une manière différente, et la APIUsageClass est disponible pour ceux qui veulent quelque chose de plus simple.

En fin de compte, ce que je vais faire c'est de faire le APIClass interne, et seulement exposer ma classe héritée.

J'ai testé toutes les solutions proposées et elles ne sont pas vraiment cacher de nouveaux membres.

Mais celui-ci N':

[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public new string MyHiddenProperty
{ 
    get { return _myHiddenProperty; }
}

Mais dans le code-behide il est toujours accessible, de manière à ajouter ainsi Obsolète Attribut

[Obsolete("This property is not supported in this class", true)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public new string MyHiddenProperty
{ 
    get { return _myHiddenProperty; }
}

Alors que clairement indiqué ci-dessus qu'il n'est pas possible en C# pour changer les modificateurs d'accès sur les méthodes héritées et les propriétés, j'ai surmonté ce problème à travers une sorte de "faux héritage" à l'aide de la conversion implicite.

Exemple:

public class A
{
      int var1;
      int var2;

      public A(int var1, int var2)
      {
            this.var1 = var1;
            this.var2 = var2;
      }
      public void Method1(int i)
      {
            var1 = i;
      }
      public int Method2()
      {
            return var1+var2;
      }
}

Maintenant, disons que vous voulez un class B d'hériter de class A, mais que vous voulez modifier certains accessibilité ou même de changer Method1 entièrement

public class B
{
      private A parent;

      public B(int var1, int var2)
      {
            parent = new A(var1, var2);
      } 

      int var1 
      {
            get {return this.parent.var1;}
      }
      int var2 
      {
            get {return this.parent.var2;}
            set {this.parent.var2 = value;}
      }

      public Method1(int i)
      {
            this.parent.Method1(i*i);
      }
      private Method2()
      {
            this.parent.Method2();
      }


      public static implicit operator A(B b)
      {
            return b.parent;
      }
}

En incluant l'implicite exprimées à la fin, il nous permet de traiter B objets comme As lorsque nous en avons besoin. Il peut également être utile de définir un cast implicite de A->B.

Le plus gros défaut de cette approche est que vous avez besoin de ré-écrire à chaque méthode/propriété que vous avez l'intention de "hériter".
Il y a probablement encore plus de défauts à cette approche, mais j'aime l'utiliser comme une sorte de "faux héritage".

Remarque:

Tout cela permet de modifier l'accessibilité de public propriétés, il ne résout pas le problème des protected propriétés publiques.