method - llamar al constructor de la clase base en c#




Llamando al constructor base en C# (8)

Si heredo de una clase base y quiero pasar algo del constructor de la clase heredada al constructor de la clase base, ¿cómo lo hago?

Por ejemplo,

Si heredo de la clase Excepción, quiero hacer algo como esto:

class MyExceptionClass : Exception
{
     public MyExceptionClass(string message, string extraInfo)
     {
         //This is where it's all falling apart
         base(message);
     }
}

Básicamente, lo que quiero es poder pasar el mensaje de cadena a la clase de excepción base.


Es cierto usar la base (algo) para llamar al constructor de la clase base, pero en caso de sobrecarga use la palabra clave this

public ClassName() : this(par1,par2)
{
// do not call the constructor it is called in the this.
// the base key- word is used to call a inherited constructor   
} 

// Hint used overload as often as needed do not write the same code 2 or more times

Modifique su constructor a lo siguiente para que llame correctamente al constructor de la clase base:

public class MyExceptionClass : Exception
{
    public MyExceptionClass(string message, string extrainfo) : base(message)
    {
        //other stuff here
    }
}

Tenga en cuenta que un constructor no es algo a lo que pueda llamar en cualquier momento dentro de un método. Esa es la razón por la que está recibiendo errores en su llamada en el cuerpo del constructor.


Si necesita llamar al constructor base pero no de inmediato porque su nueva clase (derivada) necesita hacer algo de manipulación de datos, la mejor solución es recurrir al método de fábrica. Lo que debe hacer es marcar en privado su constructor derivado, luego hacer un método estático en su clase que haga todo lo necesario y luego llamar al constructor y devolver el objeto.

public class MyClass : BaseClass
{
    private MyClass(string someString) : base(someString)
    {
        //your code goes in here
    }

    public static MyClass FactoryMethod(string someString)
    {
        //whatever you want to do with your string before passing it in
        return new MyClass(someString);
    }
}

También puede hacer una verificación condicional con parámetros en el constructor, lo que permite cierta flexibilidad.

public MyClass(object myObject=null): base(myObject ?? new myOtherObject())
{
}

o

public MyClass(object myObject=null): base(myObject==null ? new myOtherObject(): myObject)
{
}

Desde las pautas de diseño de framework y las reglas de FxCop. :

1. La excepción personalizada debe tener un nombre que termine con la excepción

    class MyException : Exception

2. La excepción debe ser pública.

    public class MyException : Exception

3. CA1032: la excepción debe implementar constructores estándar.

  • Un constructor público sin parámetros.
  • Un constructor público con un argumento de cadena.
  • Un constructor público con una cadena y una excepción (ya que puede envolver otra excepción).
  • Un constructor de serialización protegido si el tipo no está sellado y es privado si el tipo está sellado. Basado en MSDN :

    [Serializable()]
    public class MyException : Exception
    {
      public MyException()
      {
         // Add any type-specific logic, and supply the default message.
      }
    
      public MyException(string message): base(message) 
      {
         // Add any type-specific logic.
      }
      public MyException(string message, Exception innerException): 
         base (message, innerException)
      {
         // Add any type-specific logic for inner exceptions.
      }
      protected MyException(SerializationInfo info, 
         StreamingContext context) : base(info, context)
      {
         // Implement type-specific serialization constructor logic.
      }
    }  
    

o

    [Serializable()]
    public sealed class MyException : Exception
    {
      public MyException()
      {
         // Add any type-specific logic, and supply the default message.
      }

      public MyException(string message): base(message) 
      {
         // Add any type-specific logic.
      }
      public MyException(string message, Exception innerException): 
         base (message, innerException)
      {
         // Add any type-specific logic for inner exceptions.
      }
      private MyException(SerializationInfo info, 
         StreamingContext context) : base(info, context)
      {
         // Implement type-specific serialization constructor logic.
      }
    }  

usando la base se puede llamar constructor de clase base

class BaseClass
    {

    public BaseClass(int val)
    {
        Console.WriteLine($"{nameof(BaseClass) } constructor");
    }
   }

    class DerivedClass : BaseClass
    {
    public DerivedClass() : base(10)
    {
        Console.WriteLine($"{nameof(DerivedClass) } constructor");
    }
    }
    class Program
    {
        static void Main(string[] args)
        {
        BaseClass baseClass = new DerivedClass();
          Console.ReadLine();

        }
    }

public class MyException : Exception
{
    public MyException() { }
    public MyException(string msg) : base(msg) { }
    public MyException(string msg, Exception inner) : base(msg, inner) { }
}

public class MyExceptionClass : Exception
{
    public MyExceptionClass(string message,
      Exception innerException): base(message, innerException)
    {
        //other stuff here
    }
}

Puedes pasar una excepción interna a uno de los constructores.







constructor