Расширение вложенного класса в производном классе C#

Question

Я хочу иметь базовый класс с вложенным классом внутри него - и развернуть вложенный класс в дочернем классе: По какой-то причине - я не могу получить доступ к вложенному производному классу NEW (добавлены) свойства:

public class BaseClass 
{ 
    public NestedClass nestedClass {get; set;} 
    public BaseClass() 
    { 
     nestedClass = new NestedClass(); 
    } 
    public int baseproperty {get; set;} 
    public class NestedClass 
    { 
     public int NestedProperty {get; set;} 
    } 
} 

public class Derived : BaseClass 
{ 
    public class NestedClass 
    { 
      public DeeperNestedClass deeper {get; set;} 
      public NestedClass() 
      { 
       deeper = new DeeperNestedClass(); 
      } 
      public class DeeperNestedClass 
      { 
       public int VeryDeepPropery {get; set;} 
      } 


    } 
} 

Derived MyDerived = new Derived(); 
MyDerived.nestedClass.deeper <----- Doesn't recognized ! 

* редактировать - исправлен недостающий «класс» в базовом классе

Answer 1

Вы в основном есть три проблемы:

1) Вы на самом деле должны получают Derived.NestedClass от BaseClass.NestedClass.

2) Ваша недвижимость BaseClass.nestedClass всегда будет иметь тип BaseClass.NestedClass, поэтому вам необходимо бросить ее для доступа к объекту deeper.

3) Вы должны убедиться, что на объекте BaseClass.nestedClass имеется объект типа Derived.NestedClass при доступе в Derived.

public class BaseClass { 
    public NestedClass nestedClass { get; set; } 

    public BaseClass() { 
     nestedClass = new NestedClass(); 
    } 

    public int baseproperty { get; set; } 

    public class NestedClass { 
     public int NestedProperty { get; set; } 
    } 
} 

public class Derived : BaseClass { 
    public Derived() { 
     nestedClass = new NestedClass(); 
    } 

    public class NestedClass : BaseClass.NestedClass { 
     public DeeperNestedClass deeper { get; set; } 

     public NestedClass() { 
     deeper = new DeeperNestedClass(); 
     } 

     public class DeeperNestedClass { 
     public int VeryDeepPropery { get; set; } 
     } 
    } 
} 

class Program { 
    static void Main(string[] args) { 
     Derived derived = new Derived(); 
     BaseClass.NestedClass nestedBase = derived.nestedClass; 
     Derived.NestedClass nestedDerived = (Derived.NestedClass)nestedBase; 
     Derived.NestedClass.DeeperNestedClass deeper = nestedDerived.deeper; 
     int property = deeper.VeryDeepPropery; 
    } 
} 

---

Edit после обсуждения в комментариях: Может быть что-то простое, как это будет работать для вас?

public class OuterClass { 
    public OuterClass() { 
     nestedClass = new NestedClass(); 
    } 

    public int baseproperty { get; set; } 
    public NestedClass nestedClass { get; set; } 
} 

public class NestedClass { 
    public NestedClass() { 
     deeper = new DeeperNestedClass(); 
    } 
    public int NestedProperty { get; set; } 
    public DeeperNestedClass deeper { get; set; } 
} 

public class DeeperNestedClass { 
    public int VeryDeepPropery { get; set; } 
} 

class Program { 
    static void Main(string[] args) { 
     OuterClass outer = new OuterClass(); 
     int property = outer.nestedClass.deeper.VeryDeepPropery; 
    } 
} 

Answer 2

Прежде всего, вы должны указать, что NestedClass является class и partial во время его декларации:

public partial class NestedClass // You forgot those two here... 
{ 
    public int NestedProperty { get; set; } 
} 

Кроме того, вы не можете разделить вложенный класс на два отдельных класса, даже если один из них происходит от другого. Вы можете сделать это только в исходном базовом классе, если вы разделили его и отметили как частичное: http://msdn.microsoft.com/en-us/library/wa80x488(v=vs.120).aspx

Хорошо .. по крайней мере, не в здравом смысле. cremor, похоже, разобрался в работе, но я бы избежал такого кода.

Answer 3

Вы не можете иметь частичные классы, вложенные в разные классы.

В противном случае, каково было бы это полное имя?

Namespace.BaseClass.NestedClass или Namespace.Derived.NestedClass? Было бы неразумно, если бы разные имена относились к одному классу.

По этой же причине вы не можете иметь его в разных пространствах имен.

Возможным решением было бы создать интерфейс:

interface INested { } 

И сделать свой BaseClass родовое:

class BaseClass<T> where T : INested, new() 
{ 
    public T Nested { get; set; } 
    public BaseClass() 
    { 
     Nested = new T(); 
    } 
} 

class Derived : BaseClass<NestedImpl> 
{ 
    Derived() 
    { 
     Nested = new NestedImpl(); 
    } 

    public class NestedImpl : INested 
    { 
     public int deeper {get;set;} 
    } 
}