overload - c# default constructor




Aufruf des Basiskonstruktors in C# (7)

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.


Ä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.


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

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

Sie können auch eine bedingte Prüfung durchführen und Eigenschaften im Konstruktor übergeben, 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)
{
}

Wenn Sie den Basiskonstruktor nicht sofort aufrufen müssen, da Ihre neue (abgeleitete) Klasse eine Datenmanipulation 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);
    }
}

Von Framework Design Guidelines 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. Basierend 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.
      }
    }  

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

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

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.





constructor