metodos - initialize base class c#

Orden de ejecución del constructor C#

Question

En C #, cuando lo haces

Class(Type param1, Type param2) : base(param1)

¿se ejecuta primero el constructor de la clase y luego se llama al constructor de la superclase o llama primero al constructor base?

Answer 1

El constructor de la clase base se llama primero.

Answer 2

El mecanismo constructor es mucho mejor, ya que deja la aplicación para usar el encadenamiento de constructores y, si extendiera la aplicación, habilitaría, mediante herencia, la capacidad de realizar cambios mínimos en el código. Jon Skeets Artículo

Answer 3

El orden es:

• Las variables de miembro se inicializan a los valores predeterminados para todas las clases en la jerarquía

Luego, comenzando con la clase más derivada:

• Los inicializadores de variables se ejecutan para el tipo más derivado
• El encadenamiento de constructores determina qué constructor de clase base se va a llamar
• La clase base se inicializa (recurse todo esto :)
• Se ejecutan los cuerpos de constructor en la cadena en esta clase (tenga en cuenta que puede haber más de uno si están encadenados con Foo() : this(...) etc.

Tenga en cuenta que en Java, la clase base se inicializa antes de que se ejecuten los inicializadores de variables. Si alguna vez transfiere un código, esta es una diferencia importante que debe saber :)

Tengo una página con más detalles si estás interesado.

Answer 4

No estoy seguro si esto debería ser un comentario / respuesta, pero para aquellos que aprenden por ejemplo, este violín también ilustra el orden: https://dotnetfiddle.net/kETPKP

using System;
// order is approximately
/*
1) most derived initializers first.
2) most base constructors first (or top-level in constructor-stack first.)
*/
public class Program
{
public static void Main()
{
var d = new D();
}
}
public class A
{
public readonly C ac = new C("A");
public A()
{
Console.WriteLine("A");
}
public A(string x) : this()
{
Console.WriteLine("A got " + x);
}
}
public class B : A
{
public readonly C bc = new C("B");
public B(): base()
{
Console.WriteLine("B");
}
public B(string x): base(x)
{
Console.WriteLine("B got " + x);
}
}
public class D : B
{
public readonly C dc = new C("D");
public D(): this("ha")
{
Console.WriteLine("D");
}
public D(string x) : base(x)
{
Console.WriteLine("D got " + x);
}
}
public class C
{
public C(string caller)
{
Console.WriteLine(caller + "''s C.");
}
}

Resultado:

D''s C.
B''s C.
A''s C.
A
A got ha
B got ha
D got ha
D

Answer 5

Primero llamará al constructor base. También tenga en cuenta que si no coloca :base(param1) después de su constructor, se :base(param1) el constructor vacío de la base.

Answer 6

Tu pregunta es un poco confusa, pero supongo que quisiste preguntarle lo siguiente

Cuándo debo llamar al constructor base para mi objeto XNA frente al uso del constructor predeterminado impilict

La respuesta a esto depende en gran medida tanto de su escenario como del objeto subyacente. ¿Podría aclarar un poco con el siguiente

• Cuál es el escenario
• ¿Cuál es el tipo de objeto base de TerrainCollision ?

Sin embargo, mi mejor respuesta es que, en el caso de que tenga parámetros que se alineen con los parámetros del constructor de la clase base, seguramente debería llamarlo.

Answer 7

[Editar: en el tiempo que tardé en responder, la pregunta había cambiado por completo].

La respuesta es que llama primero a la base.

[Respuesta original a la pregunta anterior a continuación]

¿Estás preguntando cuándo harías el bit "base" de la llamada al constructor?

Si es así, "encadena" una llamada a la base del constructor si la clase se deriva de otra clase que tiene este constructor:

 public class CollisionBase
{
public CollisionBase(Body body, GameObject entity)
{
}
}
public class TerrainCollision : CollisionBase
{
public TerrainCollision(Body body, GameObject entity)
: base(body, entity)
{
}
}

En este ejemplo, TerrainCollision deriva de CollisionBase . Encadenando los constructores de esta manera, se asegura que se llame al constructor especificado en la clase base con los parámetros proporcionados, en lugar del constructor predeterminado (si hay uno en la base)