Использование перегруженной функции для перебора List‹Base›

Здесь есть несколько вариантов, но на самом деле все сводится к тому, как doStuuf узнать, что делать, если в будущем вы собираетесь добавлять новые производные типы?

Итак, один из вариантов: если Container действительно содержит только 1 тип за раз, вы можете сделать его универсальным:

class Container<T> where T: Base
{
    public List<T> Items { get; }
}

Теперь, когда вы выполняете итерацию, вы знаете, что Items — это список из DerivedA или DerivedB.

Container<DerivedA> container = ReturnsContainerOfDerivedA();
foreach (var item in container.Items)
{
    doStuff(item); // item is definately DerivedA
}

Это означало бы, что у вас либо есть несколько методов doStuff

public void doStuff(DerivedA item){...}
public void doStuff(DerivedB item){...}

или, если более уместно, вы можете иметь 1, который берет базу

public void doStuff(Base item){...}

В этом преимущество простого полиморфизма!

Второй вариант — определить doStuff как принимающий dynamic, если вы используете C#3.5.

public void doSomething(dynamic item){..}

Но лично я бы избегал этого варианта!

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

Например. реализовать две перегрузки:

void doStuff(DerivedA a) {
  ...
}

void doStuff(DerivedB b) {
  ...
}

И вызовите их из цикла:

foreach (dynamic item in container.Items)
  doStuff(item);

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

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

После того, как вы сделали это, Container не нужно приводить/преобразовывать объект во что-либо, кроме Base, каждый Base уже будет иметь всю информацию, необходимую для одного метода doStuff.

Самое простое решение (без изменения Base/DerivedA и т. д.) — привести объекты к dynamic. :

foreach (dynamic item in container.Items)
{
    doStuff(item);
}