c# - sobreescritura - sobrecarga de metodos en programacion orientada a objetos

¿Puedo llamar a un constructor sobrecargado de otro constructor de la misma clase en C#?

Question

¿Puedo llamar a un constructor sobrecargado de otro constructor de la misma clase en C #?

Answer 1

EDITAR: De acuerdo con los comentarios en la publicación original, esta es una pregunta de C #.

Respuesta corta: sí, usando la palabra clave this .

Respuesta larga: sí, usando la palabra clave this , y aquí hay un ejemplo.

class MyClass
{
   private object someData;

   public MyClass(object data)
   {
      this.someData = data;
   }

   public MyClass() : this(new object())
   {
      // Calls the previous constructor with a new object, 
      // setting someData to that object
   }
}

Answer 2

En C # no es posible llamar a otro constructor desde dentro del cuerpo del método. Puede llamar a un constructor base de esta manera: foo (args): base () como se señaló usted mismo. También puede llamar a otro constructor en la misma clase: foo (args): this ().

Cuando quieres hacer algo antes de llamar a un constructor base, parece que la construcción de la base es una clase que depende de algunas cosas externas. Si es así, debes hacerlo a través de argumentos del constructor base, no estableciendo propiedades de la clase base o algo así

Answer 3

No, no puedes hacer eso, el único lugar donde puedes llamar al constructor desde otro constructor en C # es inmediatamente después de ":" después del constructor. por ejemplo

class foo
{
    public foo(){}
    public foo(string s ) { }
    public foo (string s1, string s2) : this(s1) {....}

}

Answer 4

Si te refieres a si puedes hacer ctor encadenamiento en C #, la respuesta es sí. La pregunta ya ha sido hecha.

Sin embargo, parece que a partir de los comentarios, parece que lo que realmente pretendes preguntar es ''¿Puedo llamar a un constructor sobrecargado desde otro constructor con procesamiento previo / posterior?''
Aunque C # no tiene la sintaxis para hacer esto, puede hacer esto con una función de inicialización común (como lo haría en C ++ que no admite el encadenamiento de ctor)

class A
{
  //ctor chaining
  public A() : this(0)
  {  
      Console.WriteLine("default ctor"); 
  }

  public A(int i)
  {  
      Init(i); 
  }

  // what you want
  public A(string s)
  {  
      Console.WriteLine("string ctor overload" );
      Console.WriteLine("pre-processing" );
      Init(Int32.Parse(s));
      Console.WriteLine("post-processing" );
  }

   private void Init(int i)
   {
      Console.WriteLine("int ctor {0}", i);
   }
}