Доступ к свойству производного класса от базового класса в C#

В дополнение к ответу TimJ можно записать один дополнительный метод, который будет работать на все типы:

public static IEnumerable<T> OfType<T>(this IEnumerable list)
{
    foreach (var obj in list)
    {
        if (obj is T)
            yield return (T)obj;
    }
}

Или если у Вас есть Linq, та функция находится в Системе пространства имен. Linq.

   BaseClass o = MyList[i];
   if (o is ClassB)
   {
      object k = ((ClassB)o).PropertyB;
   }
   if (o is ClassA))
   {
      object j = ((ClassA)o).PropertyA;
   }

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

  public static class MyBaseListExtensions
  {
    public static IEnumerable<ClassA> GetAllAs(this List<MyBaseClass> list)
    {
      foreach (var obj in list)
      {
        if (obj is ClassA)
        {
          yield return (ClassA)obj;
        }
      }
    }

    public static IEnumerable<ClassB> GetAllbs(this List<MyBaseClass> list)
    {
      foreach (var obj in list)
      {
        if (obj is ClassB)
        {
          yield return (ClassB)obj;
        }
      }
    }
  }

Затем Вы могли использовать его как....

private void button1_Click(object sender, EventArgs e)
{
  ClassA a1 = new ClassA() { PropertyA = "Tim" };
  ClassA a2 = new ClassA() { PropertyA = "Pip" };
  ClassB b1 = new ClassB() { PropertyB = "Alex" };
  ClassB b2 = new ClassB() { PropertyB = "Rachel" };

  List<MyBaseClass> list = new List<MyBaseClass>();
  list.Add(a1);
  list.Add(a2);
  list.Add(b1);
  list.Add(b2);

  foreach (var a in list.GetAllAs())
  {
    listBox1.Items.Add(a.PropertyA);
  }

  foreach (var b in list.GetAllbs())
  {
    listBox2.Items.Add(b.PropertyB);
  }
}

Целая предпосылка не имеет смысла - чем PropertyB был бы для экземпляр?

Можно сделать это, если Вы делаете ручную проверку типа выполнения (inst, Foo), и затем бросок к типу со свойством, которое Вы хотите.

Вы должны были бы иметь свойства быть объявленными как виртуальные на базовом классе и затем переопределить их в производном классе.

Исключая:

public class ClassA : BaseClass
{
   public override object PropertyA { get; set; }
}

public class ClassB: BaseClass
{
    public override object PropertyB { get; set; }
}

public class BaseClass
{
    public virtual object PropertyA { get; set; }
    public virtual object PropertyB { get; set; }
}

public void Main
{
    List<BaseClass> MyList = new List<BaseClass>();
    ClassA a = new ClassA();
    ClassB b = new ClassB();

    MyList.Add(a);
    MyList.Add(b);

    for(int i = 0; i < MyList.Count; i++)
    {
     // Do something here with the Property
        MyList[i].PropertyA;
        MyList[i].PropertyB;      
    }
}

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

Необходимо также отметить, что Вы могли возвратиться, разные вещи для говорят что PropertyA overrideing это в обоих производных классах и возвращении различных значений.

У Вас могли бы быть некоторые проблемы с Дженериками и подклассами (в этом случае, необходимо вернуться к Системе. Наборы. ArrayList), но необходимо бросить BaseClass к подклассу, который Вы хотите использовать. Если Вы будете использовать 'в качестве' каталога, то он успешно выполнится, если BaseClass может быть литым к подклассу, или это будет пустым, если он не может быть брошен. Это посмотрело бы что-то как:

for(int i = 0; i < MyList.Count; i++)
{
    BaseClass bc = MyList[i];
    ClassA a = bc as ClassA;
    ClassB b = bc as ClassB;
    bc.BaseClassMethod();
    if (a != null) {
       a.PropertyA;
    }
    if (b != null) {
       b.PropertyB;
    }
}

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