Llamar al constructor base en C#

Question

Si me heredar de una clase base y desea pasar algo desde el constructor de la clase heredada al constructor de la clase base, ¿cómo puedo hacer eso?

Por ejemplo,

Si me heredar de la clase de 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 ser capaz de pasar el mensaje de cadena para la base de la clase de Excepción.

Answer 1

Modificar el constructor a la siguiente que llama constructor de la clase base correctamente:

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

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

Answer 2

Tenga en cuenta que usted puede utilizar estática métodos en la llamada al constructor base.

class MyExceptionClass : Exception
{
     public MyExceptionClass(string message, string extraInfo) : 
         base(ModifyMessage(message, extraInfo))
     {
     }

     private static string ModifyMessage(string message, string extraInfo)
     {
         Trace.WriteLine("message was " + message);
         return message.ToLowerInvariant() + Environment.NewLine + extraInfo;
     }
}

Answer 3

Si necesita llamar al constructor base, pero no de inmediato, porque su nuevo (derivados) las necesidades de la clase para hacer algo de manipulación de datos, la mejor solución es recurrir al método de fábrica.Lo que usted necesita hacer es marcar privado derivados de su constructor, a continuación, hacer un método estático en la clase que va a hacer todas las cosas necesarias y después de la llamada 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);
    }
}

Answer 4

Es cierto que el uso de la base (algo) para llamar constructor de la clase base, pero en el caso de la sobrecarga de uso de la this palabras clave

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

Answer 5

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

Se puede pasar de la excepción interna a uno de los constructores.

Answer 6

De Marco De Las Directrices De Diseño y FxCop reglas.:

1.Excepción personalizada debe tener un nombre que termina con Excepción

    class MyException : Exception

2.Excepción debe ser público

    public class MyException : Exception

3. CA1032:Excepción debe implementa el estándar de constructores.

• Un público constructor sin parámetros.
• Un público constructor con un argumento de cadena.
• Un constructor público con una cadena y de Excepción (como se puede envolver otra Excepción).

• Una serialización constructor protegido si el tipo no está sellado y privada en caso de que 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.
      }
    }  

Answer 7

Usted también puede hacer un condicional de verificación de parámetros en el constructor, que permite una cierta flexibilidad.

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

o

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

Answer 8

class Exception
{
     public Exception(string message)
     {
         [...]
     }
}

class MyExceptionClass : Exception
{
     public MyExceptionClass(string message, string extraInfo)
     : base(message)
     {
         [...]
     }
}

Answer 9

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

Answer 10

Como por algunas de las otras respuestas enumerados a continuación, puede pasar parámetros en el constructor de la clase base.Se recomienda llamar a su constructor de la clase base en el principio de que el constructor de la clase heredada.

public class MyException : Exception
{
    public MyException(string message, string extraInfo) : base(message)
    {
    }
}

Tomo nota de que en su ejemplo, usted nunca hicieron uso de la extraInfo parámetro, de modo que supuse que usted podría desea concatenar el extraInfo parámetro de cadena para la Message propiedad de la excepción (parece que esto está siendo ignorada en la aceptación de la respuesta y el código en tu pregunta).

Esto es conseguido simplemente invocando el constructor de la clase base, y, a continuación, actualizar el Mensaje de la propiedad con la información adicional.

public class MyException: Exception
{
    public MyException(string message, string extraInfo) : base($"{message} Extra info: {extraInfo}")
    {
    }
}