c# - texto - ¿Hay una manera de llamar automáticamente a un método en particular inmediatamente después de que todos los constructores se hayan ejecutado?

que pasa si contesto una llamada de mi mismo numero

Question

Quiero poder llamar automáticamente a un método en particular al construir un objeto derivado, sin embargo, no puedo pensar cómo hacerlo. El siguiente código lo ilustra. Otra respuesta recomendó OnLoad, pero estoy haciendo esto para Unity en Mac y parece que OnLoad no es compatible con mi plataforma. ¿Alguna sugerencia?

public class Parent {

    public Parent ()
    {
        // A. Stuff to do before child constructor code runs
        DoThisAutomaticallyAfterConstruction();
    }

    public void DoThisAutomaticallyAfterConstruction()
    {
        // C. In this example, this will run after A, before B. I want it to run ABC
    }
}

public class Child : Parent {

    public Child () : base()
    {
        // B. Stuff to do here after parent constructor code runs
    }
}

Answer 1

Basado en su ejemplo, usted está logrando ACB , quiere lograr ABC .

Para ejecutar el código después del constructor secundario, debe realizar la llamada después de B (el constructor secundario), no puede llamar al código en A (el constructor principal), por lo que no cumplirá los requisitos de ABC.

¿ DoThisAutomaticallyAfterConstruction() mover DoThisAutomaticallyAfterConstruction() al final del constructor de la clase secundaria?

Verdaderamente una pregunta extraña sin embargo.

Answer 2

Desafortunadamente, no hay una forma integrada de hacer lo que quiere (es una función que se solicita con bastante frecuencia).

Una solución es implementar un patrón de fábrica, donde no cree objetos llamando directamente al constructor, sino implementando un método estático para crearlos por usted. Por ejemplo:

public class MyClass
{
  public MyClass()
  {
    // Don''t call virtual methods here!
  }

  public virtual void Initialize()
  {
    // Do stuff -- but may be overridden by derived classes!
  }
}

Luego añade:

public static MyClass Create()
{
  var result = new MyClass();

  // Safe to call a virtual method here
  result.Initialize();

  // Now you can do any other post-constructor stuff

  return result;
}

y en lugar de hacer

var test = new MyClass();

tu puedes hacer

var test = MyClass.Create();

Answer 3

Esto suena como un buen candidato para una fábrica. Haga que todos los constructores sean privados o protegidos, que requieran que los consumidores de su código llamen al método de fábrica cuando quieran una instancia de su objeto. En el método de fábrica, utiliza el new operador para crear el objeto y luego llama a DoThisAutomaticallyAfterConstruction() antes de devolver el objeto.

EDITAR

Una fábrica puede ser un método estático, o usted puede tener un objeto de fábrica. Consulte, por ejemplo, Wikipedia sobre el patrón de fábrica abstracto en http://en.wikipedia.org/wiki/Abstract_factory_pattern , y la documentación de ADO.NET DbProviderFactories en http://msdn.microsoft.com/en-us/library/wda6c36e.aspx para una implementación en el mundo real.

Answer 4

Si bien la respuesta (aceptada) de @Jeremy Todd funciona y es una solución ampliamente aceptada para el problema, tiene un inconveniente: no es muy compatible con IoC ni con la serialización, ya que su clase no se puede construir de forma adecuada utilizando new . Permítame presentarle una solución general usando algunas características de C #. Tenga en cuenta que esta solución no requiere que use un patrón de fábrica o invoque nada después de construir el objeto, y funciona en cualquier clase con solo implementar una interfaz con un solo método. Primero declaramos una interfaz que nuestras clases deberán implementar:

public interface IInitialize {
    void OnInitialize();
}

A continuación, agregamos una clase de extensión estática para esta interfaz y agregamos el método de inicialización:

public static class InitializeExtensions
{
    public static void Initialize<T>(this T obj) where T: IInitialize
    {
        if (obj.GetType() == typeof(T))    
            obj.OnInitialize();
    }
}

Ahora, si necesitamos una clase y todos sus descendientes para llamar a un inicializador justo después de que el objeto se haya construido completamente, todo lo que tenemos que hacer es implementar la IInitialize y añadir una línea en el constructor:

public class Parent : IInitialize
{
    public virtual void OnInitialize()
    {
        Console.WriteLine("Parent");
    }

    public Parent()
    {
        this.Initialize();
    }
}

public class Child : Parent
{
    public Child()
    {
        this.Initialize();
    }

    public override void OnInitialize()
    {
        Console.WriteLine("Child");
    }
}

public class GrandChild : Child
{
    public GrandChild()
    {
        this.Initialize();
    }

    public override void OnInitialize()
    {
        Console.WriteLine("GrandChild");
    }
}

El truco es que cuando una clase derivada llama al método de extensión Initialize , eso suprimirá cualquier llamada no realizada desde la clase real.