Я не понимаю наследование с базовыми классами

Пример, который вы привели, включает интерфейс IDisposable. В C# класс может реализовывать несколько интерфейсов.

С другой стороны, в C# класс может наследоваться только от одного класса.

Сказав это, не всегда хорошая идея наследовать от классов, так как это очень ограничивает. Вместо этого я бы предложил состав: wiki

Например, я бы предложил что-то вроде шаблона проектирования композиции (это небольшая вариация, так как композит не имеет набора объектов, а только один объект):

public interface IFoo
{
    void DoFooStuff();
}

public class Foo : IFoo
{
    public void DoFooStuff() {...};
}

public class ShouldImplementFoo : IFoo
{
    // Composition, you need to initialize it some time
    private Foo _foo;
    
    public void DoFooStuff() { _foo.DoFooStuff(); }
}

ИЗМЕНИТЬ

После переосмысления вашей проблемы вы, кажется, хотите поместить некоторый набор объектов (разных классов) в список, чтобы вы могли выполнить некоторое определенное действие для каждого объекта в списке.

Самое простое: определить интерфейс с вашим определенным действием:

public interface IMyIntf
{
    void MyDesiredAction();
}

А теперь сделайте так, чтобы все классы реализовали это. Теперь вы можете подумать Ну, теперь мне нужно внедрить этот метод везде... - ничего подобного! Просто используйте шаблон проектирования адаптера, например, имея класс:

public class MyConcreteClass
{
    public void ActionIWishToExecuteOnThisObject() 
    { ... }
}

вы просто измените его на:

public class MyConcreteClass : IMyIntf
{
    public void ActionIWishToExecuteOnThisObject() 
    { ... }

    // implement interface
    public void MyDesiredAction()
    {
        ActionIWishToExecuteOnThisObject();
    }
}

Теперь вы можете использовать какой-нибудь агрегат, например List<IMyIntf>, поместить туда все интересующие вас объекты и сделать:

foreach(var item in myList)
    item.MyDesiredAction();

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

var disposables = new List<IDisposable>();
disposables.Add(new MyClass1());
disposables.Add(new SomeClass());
disposables.Add(new AnotherClass());

disposables.ForEach(d => d.Dispose());

Является ли это достойным шаблоном, я не уверен!

Класс может наследовать от класса-предка (иначе Object, корень всего).

Также он может реализовывать некоторые интерфейсы (или ни один).

Класс может иметь нереализованные члены как абстрактные, поэтому класс является абстрактным.

Также члены могут быть виртуальными, чтобы включить полиморфизм (абстрактные члены).

После реализации в классе доступна вещь, которая может быть создана как настоящая, если не абстрактная, и доступна для всех дочерних элементов, за исключением частных, которые скрыты в подклассе.

Нет необходимости повторяться, и в этом одна из сильных сторон ООП.

Делая это, используя абстракцию, инкапсуляцию, наследование и полиморфизм, после изучения реального мира и области, в которой мы работаем, мы можем разработать проекцию этого реального мира, представление в нашем уме, с понятиями, имеющими данные (поля и свойства) и операции (методы), классифицируемые по артефактам (объектам) и такие вещи, как отношения, композиция, агрегация, интерфейсы, компоненты, элементы управления и т. д.

Таким образом, мы можем факторизовать обработки, чтобы они не повторялись, например:

• Имея класс Animal и дочерние классы Cat и Dog,
• Мы вкладываем в животное аспекты Size и Color,
• А также методы Eat и Walk, реализованные для всех животных,
• И абстрактный нереализованный DoSound.

Следовательно:

• В конкретных классах Cat и Dog мы не реализуем снова вещи,
• За исключением DoSound, который индивидуален для каждого реального пола животного.

Что касается интерфейсов, то это виртуальные контракты.

Например, у нас могут быть животные и здания, которые на первый взгляд не имеют ничего общего (мы не будем возвращаться к атомам и фотонам), но мы хотим иметь возможность управлять экземплярами таких объектов, как кошка и собака, а также дом и музей, чтобы сделать фото.

Для этого мы определяем интерфейс IPhotoTaking и при определении предыдущих классов добавляем, что они реализуют этот интерфейс.

Пример кода:

public interface IPhotoTaking
{
  Image TakePhoto();
}

public abstract class Animal : IPhotoTaking
{
  public int Size { get; set; }
  public Color Color { get; set; }
  public void Eat() { ... }
  public void Walk() { ... }
  public abstract void DoSOund();
  public Image TakePhoto();
}

public class Cat : Animal // no need to repeat IPhotoTaking
{
  public override void DoSound() { ... }
}

public class Dog : Animal
{
  public override void DoSound() { ... }
}

public abstract class Building :IPhotoTaking
{
  public Image TakePhoto();
}

public class House : Building
{
}

public class Museum : Building
{
}

Теперь, имея этот список, мы можем использовать полиморфизм следующим образом:

var animals = new List<Animal>();

foreach ( var animal in animals )
  animal.DoSound();

Также без полиморфизма и поскольку C# не поддерживает настоящий полиморфизм с оператором алмаза, который все же применяется здесь к List<>, мы можем использовать такой интерфейс:

var items = new List<IPhotoTaking>();

foreach ( var item in items )
  item.TakePhoto();

Примечание: если фотографирование может быть разным для каждого типа, мы можем установить его виртуальным, чтобы специализировать его реализацию в каждом из них.

Основные принципы ООП

Что такое абстракция в C#?

Как выбрать между общедоступный, частный и защищенный модификатор доступа?

Ассоциация, композиция и агрегация

Что такое полиморфизм?

В чем разница между интерфейсом и классом?

Об отсутствии истинного универсального полиморфизма и отсутствующий оператор алмаза в C#