C# - Могут публично наследованные методы быть скрытыми (например, сделанными частные к производному классу)

Это походит на плохую идею. Liskov не был бы впечатлен.

, Если Вы не хотите, чтобы потребители DerivedClass были в состоянии к методам доступа DeriveClass. () и DerivedClass. B () я предложил бы, чтобы DerivedClass реализовал некоторый открытый интерфейс, IWhateverMethodCIsAbout и потребители DerivedClass должны на самом деле говорить с IWhateverMethodCIsAbout и ничего не знать о реализации BaseClass или DerivedClass вообще.

то, В чем Вы нуждаетесь, является составом не наследование.

class Plane
{
  public Fly() { .. }
  public string GetPilot() {...}
}

Теперь при необходимости в специальном виде Плоскости, такой как та, которая имеет PairOfWings = 2, но иначе делает все, плоскость может.. Вы наследовали плоскость. Этим Вы объявляете, что Ваша деривация выполняет контракт базового класса и может быть заменена, не мигая везде, где базовый класс ожидается. например, LogFlight (Плоскость) продолжил бы работать с экземпляром BiPlane.

Однако, если Вам просто нужно поведение Мухи для нового Bird, Вы хотите создать и не готовы поддерживать полный контракт базового класса, Вы сочиняете вместо этого. В этом случае осуществите рефакторинг поведение методов к повторному использованию в новый Полет типа. Теперь создайте и держите ссылки на этот класс и в Плоскости и в Bird. Вы не наследовались, потому что Bird не поддерживает полный контракт базового класса... (например, он не может обеспечить GetPilot ()).

По той же причине, Вы не можете уменьшить видимость методов базового класса, когда Вы переопределяете.. можно переопределить и обнародовать основной закрытый метод в деривации, но не наоборот. например, В этом примере, если я получаю тип Плоскости "BadPlane" и затем переопределяю и "Скрываю" GetPilot () - делают его частным; клиентский метод LogFlight (Плоскость p) будет работать на большинство Плоскостей, но аварийно завершится для "BadPlane", если реализация LogFlight, окажется, будет нуждаться/называть в GetPilot (). , Так как все деривации базового класса, как ожидают, будут 'substitutable' везде, где параметрический усилитель базового класса ожидается, это должно быть запрещено.

Единственный способ сделать это, что я знаю о, должно использовать - отношения и только реализовать функции, которые Вы хотите представить.

@Brian R. Bondy указал на меня на интересную статью о Сокрытии посредством наследования и новый ключевое слово.

http://msdn.microsoft.com/en-us/library/aa691135 (По сравнению с 71) .aspx

Поэтому как обходное решение я предложил бы:

class BaseClass
{
    public void A()
    {
        Console.WriteLine("BaseClass.A");
    }

    public void B()
    {
        Console.WriteLine("BaseClass.B");
    }
}

class DerivedClass : BaseClass
{
    new public void A()
    {
        throw new NotSupportedException();
    }

    new public void B()
    {
        throw new NotSupportedException();
    }

    public void C()
    {
        base.A();
        base.B();
    }
}

Этот путь код как это бросит NotSupportedException:

    DerivedClass d = new DerivedClass();
    d.A();

Сокрытие является довольно скользким путем. Основные вопросы, IMO:

• Это зависит от типа объявления времени проектирования экземпляра, означая, делаете ли Вы что-то как BaseClass obj = новый SubClass (), затем назовите obj. (), сокрытие побеждено. BaseClass. () будет выполняться.

• Сокрытие может очень легко затенить поведение (или изменения поведения) в базовом типе. Это - очевидно, меньше беспокойства при владении обеими сторонами уравнения, или если вызов 'base.xxx' является частью подучастника.

• , Если Вы на самом деле делаете собственный обе стороны уравнения основы/подкласса, тогда необходимо быть в состоянии создать более управляемое решение, чем узаконенное сокрытие/затенение.

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

предстоящую парадигму кодирования называют "Составом по Наследованию". Это играет непосредственно прочь принципов объектно-ориентированной разработки (особенно Единственный Принцип Ответственности, и Откройтесь/Закройте Principle).

, К сожалению, путь многие из нас разработчикам преподавали объектную ориентацию, мы сформировали привычку к непосредственному размышлению о наследовании вместо состава. Мы склонны иметь большие классы, которые имеют много различных обязанностей просто, потому что они могли бы содержаться с тем же объектом "Реального мира". Это может привести к иерархиям классов, которые равняются 5 + уровни глубоко.

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

Один способ разбить Ваш код через интерфейсы, любят упомянутый в другом ответе. Это - умная вещь сделать так или иначе, поскольку Вы хотите, чтобы внешние зависимости класса связали с абстракциями, не бетоном/производными типами. Это позволяет Вам изменять реализацию, не изменяя интерфейс, все, не производя строку кода в Вашем зависимом классе.

я был бы очень, а не обслуживать систему с сотнями/тысячами/ровными большего количества классов, которые являются все маленькими и слабо связываются, чем соглашение с системой, которая делает интенсивное использование полиморфизма/наследования и имеет меньше классов, которые более сильно связаны.

, Возможно, лучший ресурс там на объектно-ориентированной разработке является книгой Robert C. Martin, Гибкая разработка программного обеспечения, Принципы, Шаблоны и Методы .

Если они определяются общественность в исходном классе, Вы не можете переопределить их, чтобы быть частными в Вашем производном классе. Однако Вы могли заставить открытый метод выдать исключение и реализовать Вашу собственную закрытую функцию.

Редактирование: Jorge Ferreira корректен.

Когда вы, например, пытаетесь наследовать от List