Question

我正在扩展一个libary类，它有一个公共方法，我不想从外面调用。我知道我可以使用“new”关键字隐藏它，但问题是，它有很多不同的声明。像这样：

class Parent() {
  public double method(double a, double b) { ... }
  public int method(int a, int b) { ... }
  public System.Int32 method(System.Int32 a, System.Int32 b) { ... }
}

现在我能做到：

class Child() {  
  // Make method private.
  private new double method(double a, double b) { return base.method(a, b) }
  private new int method(int a, int b) { return base.method(a, b) }
  private new System.Int32 method(System.Int32 a, System.Int32 b) { return base.method(a, b) }

  /// Own Code.
}

但我想知道是否有一种更简单的方法可以将该功能的所有覆盖变为私有。

Answer 1

我认为第一个问题是您的后代类是否需要被转换为父类。

如果没有，那么最好的方法是使用一个外观模式，在其中隐藏“父”，只允许通过你的方法访问它。

有点像：

class Parent {
  public double method(double a, double b) { ... }
  public int method(int a, int b) { ... }
}


class YourStuff {
  private Parent _parent = new Parent();

  public int AddNumbers(int a, int b) {
     return _parent.method(a,b);
  }
}

在这种情况下，将隐藏Parent类。

Answer 2

这不是方法隐藏的方式。您的private new方法只会隐藏Child类中的原始方法（但是它们会调用它们隐藏的内容，因此无法获得任何内容）。

在源自Grandchild的{{1}}类中，不再隐藏任何内容，因为Child方法不在范围内，因此private new public方法Parent是完全可驯服和“赤裸裸”。隐藏方法不会以任何方式删除隐藏方法;这只是一个相同的方法被调用的问题。

Answer 3

如果您希望不能从外部调用名称为Method的库类Parent方法，则需要更改访问修饰符。您的类没有访问修饰符，因此默认情况下它是内部的-类型或成员可以由同一程序集中的任何代码访问，但不能从另一个程序集中访问。方法Method具有相同的可访问性，因为它具有访问修饰符public。如果您希望只能在派生类实例中访问在Method方法中实现的方法，则需要将所有访问修饰符都公共，以将重载的Method变体更改为protected，然后在子类中隐藏此方法的重载方法。如果要从外部使用这些隐藏方法，则需要将其访问修饰符从私有更改为公共。此实现的示例：

namespace HideBaseClassMethod
{
    class Program
    {
        static void Main(string[] args)
        {
            Parent myParent = new Parent();
            //myParent. - no one of overloaded protected methods are accessible after dot operator
           Child myChild = new Child();
           myChild.Method(2.5, 4.3); //double 
           myChild.Method(2, 4);//int

           Parent myChildCreatedAsParent = new Child();
           //myChildCreatedAsParent.  - no one of overloaded protected methods are accessible after dot operator
        }
    }
    class Parent 
    {
        protected double Method(double a, double b)
        {
           Console.WriteLine($"I am a parent double method {a} + {b}");
           return a + b;
        }
        protected int Method(int a, int b)
       {
            Console.WriteLine($"I am a parent integer method {a} + {b}");
            return a + b;
       }
   }
   class Child:Parent
   {
        public new double Method(double a, double b)
        {
            Console.WriteLine($"I am a child double method {a} * {b}");
            return a * b;
        }
        public new int Method(int a, int b)
        {
            Console.WriteLine($"I am a child integer method {a} * {b}");
            return a + b;
        }
    }
}

该程序执行的结果将是：

我是儿童双重方法2.5 * 4.3

我是2 * 4的子整数方法

如何隐藏C＃中父方法的所有覆盖

3 个答案: