隐藏继承的成员

时间:2008-08-04 19:13:55

标签: c# wpf silverlight polymorphism dependency-properties

我正在寻找一些有效隐藏继承成员的方法。我有一个继承自公共基类的类库。一些最近的后代类继承了依赖属性,这些属性已成为残留,在使用 IntelliSense 或在可视化设计器中使用类时可能会有点混乱。

这些类是为WPF或Silverlight 2.0编写的所有控件。我知道ICustomTypeDescriptorICustomPropertyProvider,但我很确定那些不能在Silverlight中使用。

它不是可用性问题的功能问题。我该怎么办?

更新

我真想隐藏的一些属性来自不属于我自己的祖先,而且由于我正在设计的特定工具,我不能用new运算符隐藏成员。 (我知道,这太荒谬了)

9 个答案:

答案 0 :(得分:33)

像Michael Suggests above一样覆盖它们并防止人们使用重写(sp?)方法,将它们标记为过时:

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

如果第二个parm设置为true,则如果有人试图调用该方法并且第一个parm中的字符串是消息,则会生成编译器错误。如果parm2为false,则仅生成编译器警告。

答案 1 :(得分:16)

虽然您无法阻止我对这些继承成员的使用,但您应该能够使用EditorBrowsableAttribute将其隐藏在IntelliSense中:

Using System.ComponentModel;

[EditorBrowsable(EditorBrowsableState.Never)]
private string MyHiddenString = "Muahahahahahahahaha";

编辑:刚刚在文档评论中看到了这一点,这使得它有点用于此目的:

  

有一个突出的说明,即该属性“不会抑制同一程序集中某个类的成员”。这是事实但不完整。实际上,该属性不会在同一解决方案中禁止来自类的成员。

答案 2 :(得分:13)

您可以做的一件事是包含对象而不是从另一个类扩展。这将使您在暴露要暴露的内容方面具有最大的灵活性,但如果您绝对需要该类型的对象,则它不是理想的解决方案(但是您可以从getter中公开该对象)。

因此:

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

变为:

public class MyClass
{
    private BaseClass baseClass;

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

或者:

public class MyClass
{
    private BaseClass baseClass;

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

答案 3 :(得分:8)

我认为你最好的解释方法是考虑构成而不是继承。

或者,您可以创建一个包含所需成员的接口,让派生类实现该接口,并针对该接口进行编程。

答案 4 :(得分:3)

完全隐藏和标记不使用,包括我认为是大多数读者期望的智能感知......

[Obsolete("Not applicable in this class.")] 
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]

答案 5 :(得分:3)

我知道有几个答案,现在已经很老了,但最简单的方法是将它们声明为new private

考虑一下我目前正在开发的一个示例,其中我有一个API,可以使第三方DLL中的每个方法都可用。我必须采用他们的方法,但我想使用.Net属性,而不是“getThisValue”和“setThisValue”方法。所以,我构建了第二个类,继承了第一个类,创建了一个使用get和set方法的属性,然后将原始的get和set方法覆盖为private。对于想要在其上构建不同内容的人来说,它们仍然可用,但如果他们只想使用我正在构建的引擎,那么他们将能够使用属性而不是方法。

使用double类方法消除了无法使用new声明隐藏成员的任何限制。如果成员被标记为虚拟,则您无法使用override

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

现在valueEnum可供两个类使用,但只有属性在APIUsageClass类中可见。 APIClass类仍然适用于想要扩展原始API或以不同方式使用它的人,而APIUsageClass可供那些想要更简单的人使用。

最终,我要做的是让APIClass内部化,并且只暴露我继承的类。

答案 6 :(得分:1)

我测试了所有提议的解决方案,但他们并没有真正隐藏新成员。

但这一个是:

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

但是在代码中,它仍然可以访问,因此也可以添加过时的属性

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

答案 7 :(得分:0)

虽然上面已经明确指出,在C#中无法更改继承的方法和属性的访问修饰符,但我通过使用隐式强制转换的一种“伪继承”克服了这个问题。

示例:

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

现在可以说您希望class B继承自class A,但是想要更改某些可访问性甚至是完全更改Method1

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

通过在末尾包含隐式强制转换,它使我们可以在需要时将B个对象视为A个对象。从A->B定义隐式强制转换也很有用。

此方法的最大缺陷是,您需要重写要“继承”的每个方法/属性。 这种方法可能存在更多缺陷,但是我喜欢将其用作一种“伪继承”。

注意:

虽然这允许更改public属性的可访问性,但不能解决将protected属性设为公开的问题。

答案 8 :(得分:0)

您可以使用界面

    public static void Main()
    {
        NoRemoveList<string> testList = ListFactory<string>.NewList();

        testList.Add(" this is ok ");

        // not ok
        //testList.RemoveAt(0);
    }

    public interface NoRemoveList<T>
    {
        T this[int index] { get; }
        int Count { get; }
        void Add(T item);
    }

    public class ListFactory<T>
    {
        private class HiddenList: List<T>, NoRemoveList<T>
        {
            // no access outside
        }

        public static NoRemoveList<T> NewList()
        {
            return new HiddenList();
        }
    }