¿Cómo ejecuto algún código en una superclase después de que se hayan construido todas las subclases?

Question

¿Hay alguna manera de hacer esto en C#? Sé que la subclase llamará al constructor de la superclase antes de llamar a su propio constructor, pero ¿qué ocurre si tengo algún código en la superclase que solo debería ejecutarse después de haber llamado a todos los constructores de subclases?

Answer 1

Una forma de lograr esto sería para ir de una construcción 2 de fase y inicializar. Por lo que la construcción de los casos y luego llama a un método initialize la que invoca la clase base de inicialización en el orden apropiado

class MyBase 
{ 
    // Only if need to do some core initialization 
    public MyBase() 
    { 
    } 

    public virtual Initialize() 
    { 
    // do some initialization stuff here 
    } 
} 

class MyDerived : MyBase 
{ 
    // Only if need to do some core initialization 
    public MyDerived() 
    { 
    } 

    public override Initialize() 
    { 
    // do some initialization stuff here 

    // Call the base class initialization function 
    base.Initialize(); 
    } 
} 

Answer 2

class A : B 
{ 
    public A() : base() 
    { 
     base.doSomething(); 
    } 
} 

class B : C 
{ 
    public B() : base() 
    { 

    } 

    public void doSomething() { /* ... */ } 
} 

class C 
{ 
    public C() { /* ... */ } 
} 

orden de ejecución debe ser:

1. C :: ctor()
2. B :: ctor()
3. A :: ctor()
4. B :: doSomething ()

Answer 3

No estoy seguro de lo que quiere decir, ¿no puede simplemente llamar al código en la súper clase al final de nuestra última subclase? ¿estructor? Alternativamente, puede llamarlo directamente después de la creación de instancias.

class Program 
    { 
     static void Main(string[] args) 
     { 
      SubSub obj = new SubSub();     
      //obj.DoStuff(); 
      Console.ReadLine(); 
     } 
    } 

    class Super 
    { 
     public Super() 
     { 
      Console.WriteLine("Constructing Super"); 
     } 
     public void DoStuff() 
     { 
      Console.WriteLine("Doin' stuff"); 
     } 
    } 

    class Sub : Super 
    { 
     public Sub() 
     { 
      Console.WriteLine("Constructing Sub"); 
     } 
    } 

    class SubSub : Sub 
    { 
     public SubSub() 
     { 
      Console.WriteLine("Constructing SubSub"); 
      DoStuff(); 
     } 
    } 

Esta salida voluntad:

Constructing Super 
Constructing Sub 
Constructing SubSub 
Doin' stuff 

Answer 4

Se podría hacer lo siguiente, pero es arriesgado (ver mi Editar a continuación):

public class Parent 
{ 
    public Parent() 
    { 
     Initialize(); 
    } 

    protected virtual void Initialize() 
    { 
     // do stuff 
    } 
} 

public class Child : Parent 
{ 
    protected override void Initialize() 
    { 
     // do child stuff 
     base.Initialize(); 
    } 
} 

Editar

Como se sugiere en el comentario de Terrence más adelante, este es un enfoque arriesgado porque Initialize() se ejecutará antes de ejecutar Child 's constructor. Si hay campos inicializados en el constructor Child, no estarán listos si son utilizados por Initialize(). Esto podría causar errores confusos.

Una solución simple sería renunciar a la llamada principal Initialize() y en su lugar tener las clases secundarias llamar Initialize(). Como otros han sugerido, otra opción sería usar el patrón abstracto de fábrica.

Aquí es una solución simple que utiliza un método de fábrica estática:

class Program 
{ 
    static void Main() 
    { 
     Child.Create(() => new Child(5)); 
     Console.ReadKey(); 
    } 
} 

public abstract class Parent 
{ 
    protected virtual void Initialize() 
    { 
     Console.Write(" is the number."); 
    } 

    public static TChild Create<TChild>(Func<TChild> childGetter) 
     where TChild : Parent 
    { 
     var child = childGetter(); 
     child.Initialize(); 
     return child; 
    } 
} 

public class Child : Parent 
{ 
    private int _number; 

    public Child(int number) 
    { 
     _number = number; 
    } 

    protected override void Initialize() 
    { 
     Console.Write(_number.ToString()); 
     base.Initialize(); 
    } 
} 

Answer 5

No hay nada integrado en el lenguaje C# que te permite hacer esto. Sin embargo, usar un patrón de creación podría soportarlo. Por ejemplo, el patrón Abstract Factory puede ser útil aquí. La fábrica base se aseguraría de que se invoque un método en la clase base recién creada una vez que se haya instanciado como el tipo de elemento secundario concreto.