Aufruf des Basiskonstruktors in C#

Question

Wie mache ich das, wenn ich von einer Basisklasse erbe und etwas vom Konstruktor der geerbten Klasse an den Konstruktor der Basisklasse übergeben möchte?

Zum Beispiel,

Wenn ich von der Exception-Klasse erbe, möchte ich etwa Folgendes tun:

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

Im Grunde möchte ich die String-Nachricht an die Basis-Exception-Klasse übergeben können.

Answer 1

Ändern Sie Ihren Konstruktor wie folgt, damit er den Basisklassenkonstruktor ordnungsgemäß aufruft:

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

Beachten Sie, dass Sie einen Konstruktor nicht jederzeit innerhalb einer Methode aufrufen können.Aus diesem Grund erhalten Sie bei Ihrem Aufruf im Konstruktorkörper Fehler.

Answer 2

Beachten Sie, dass Sie verwenden können statisch Methoden innerhalb des Aufrufs des Basiskonstruktors.

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

Wenn Sie den Basiskonstruktor aufrufen müssen, aber nicht sofort, weil Ihre neue (abgeleitete) Klasse einige Datenmanipulationen durchführen muss, besteht die beste Lösung darin, auf die Factory-Methode zurückzugreifen.Was Sie tun müssen, ist, Ihren abgeleiteten Konstruktor als privat zu markieren, dann eine statische Methode in Ihrer Klasse zu erstellen, die alle notwendigen Aufgaben erledigt, und später den Konstruktor aufzurufen und das Objekt zurückzugeben.

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 ist wahr, verwenden Sie die base (etwas), um den Basisklassenkonstruktor aufzurufen, aber im Falle einer Überladung verwenden Sie den this Stichwort

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
    }
}

Sie können eine innere Ausnahme an einen der Konstruktoren übergeben.

Answer 6

Aus Richtlinien für das Framework-Design und FxCop-Regeln.:

1.Eine benutzerdefinierte Ausnahme sollte einen Namen haben, der mit „Exception“ endet

    class MyException : Exception

2.Die Ausnahme sollte öffentlich sein

    public class MyException : Exception

3. CA1032:Die Ausnahme sollte Standardkonstruktoren implementieren.

• Ein öffentlicher, parameterloser Konstruktor.
• Ein öffentlicher Konstruktor mit einem String-Argument.
• Ein öffentlicher Konstruktor mit einer Zeichenfolge und einer Ausnahme (da er eine andere Ausnahme umschließen kann).

• Ein Serialisierungskonstruktor, der geschützt ist, wenn der Typ nicht versiegelt ist, und privat, wenn der Typ versiegelt ist.Bezogen auf 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.
    }
  }  
  

oder

    [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

Sie können auch eine bedingte Prüfung mit Parametern im Konstruktor durchführen, was eine gewisse Flexibilität ermöglicht.

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

oder

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

Gemäß einigen anderen hier aufgeführten Antworten können Sie Parameter an den Basisklassenkonstruktor übergeben.Es wird empfohlen, den Konstruktor Ihrer Basisklasse am Anfang des Konstruktors für Ihre geerbte Klasse aufzurufen.

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

Ich stelle fest, dass Sie in Ihrem Beispiel nie davon Gebrauch gemacht haben extraInfo Parameter, also ging ich davon aus, dass Sie den möglicherweise verketten möchten extraInfo String-Parameter zum Message Eigenschaft Ihrer Ausnahme (anscheinend wird dies in der akzeptierten Antwort und dem Code in Ihrer Frage ignoriert).

Dies wird einfach durch Aufrufen des Basisklassenkonstruktors und anschließendes Aktualisieren der Message-Eigenschaft mit den zusätzlichen Informationen erreicht.

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