Frage Aufruf des Basiskonstruktors in C #


Wenn ich von einer Basisklasse erben und etwas vom Konstruktor der geerbten Klasse an den Konstruktor der Basisklasse übergeben möchte, wie mache ich das?

Beispielsweise,

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

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

Grundsätzlich möchte ich die String-Nachricht an die Basis-Exception-Klasse übergeben können.


1154
2017-08-15 07:39


Ursprung


Antworten:


Ändern Sie Ihren Konstruktor so, dass er den Basisklassenkonstruktor richtig aufruft:

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

Beachten Sie, dass ein Konstruktor nicht jederzeit in einer Methode aufgerufen werden kann. Aus diesem Grund erhalten Sie im Konstruktorhauptteil Fehler in Ihrem Aufruf.


1471
2017-08-15 07:40



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

420
2018-04-28 17:34



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

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

77
2018-02-27 02:22



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.


21
2017-12-04 05:03



Es ist wahr, benutze die base (etwas), um den Basisklassenkonstruktor aufzurufen, aber im Falle eines Überladens 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

16
2017-11-11 11:32



Von Framework Design Richtlinien und FxCop Regeln.:

1. Benutzerdefinierte Ausnahme sollte einen Namen haben, der mit Ausnahme endet

    class MyException : Exception

2. Ausnahme sollte öffentlich sein

    public class MyException : Exception

3. CA1032: Exception sollte Standardkonstruktoren implementieren.

  • Ein öffentlicher parameterloser Konstruktor.
  • Ein öffentlicher Konstruktor mit einem String-Argument.
  • Ein öffentlicher Konstruktor mit einer Zeichenfolge und Exception (da er eine andere Exception umbrechen kann).
  • Ein Serialisierungskonstruktor ist geschützt, wenn der Typ nicht versiegelt ist, und privat, wenn der Typ versiegelt ist. Beyogen 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.
      }
    }  

12
2018-01-24 07:34



Sie können auch eine bedingte Überprü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)
{
}

7
2018-05-27 21:27



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

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

4
2018-02-26 04:11