Appel du constructeur de base en C#

Question

Si j'hérite d'une classe de base et que je souhaite transmettre quelque chose du constructeur de la classe héritée au constructeur de la classe de base, comment dois-je procéder ?

Par exemple,

Si j'hérite de la classe Exception, je veux faire quelque chose comme ceci :

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

Fondamentalement, ce que je veux, c'est pouvoir transmettre le message de chaîne à la classe Exception de base.

Answer 1

Modifiez votre constructeur comme suit afin qu'il appelle correctement le constructeur de la classe de base :

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

Notez qu'un constructeur n'est pas quelque chose que vous pouvez appeler à tout moment dans une méthode.C'est la raison pour laquelle vous obtenez des erreurs lors de votre appel dans le corps du constructeur.

Answer 2

Notez que vous pouvez utiliser statique méthodes dans l’appel au constructeur de 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 vous devez appeler le constructeur de base mais pas tout de suite parce que votre nouvelle classe (dérivée) doit effectuer des manipulations de données, la meilleure solution est de recourir à la méthode d'usine.Ce que vous devez faire est de marquer privé votre constructeur dérivé, puis de créer une méthode statique dans votre classe qui fera tout le nécessaire, puis d'appeler le constructeur et de renvoyer l'objet.

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

C'est vrai, utilise le base (quelque chose) pour appeler le constructeur de la classe de base, mais en cas de surcharge, utilisez le this mot-clé

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

Vous pouvez transmettre une exception interne à l'un des constructeurs.

Answer 6

Depuis Lignes directrices pour la conception du cadre et les règles FxCop.:

1.L'exception personnalisée doit avoir un nom qui se termine par Exception

    class MyException : Exception

2.L'exception doit être publique

    public class MyException : Exception

3. CA1032 :L'exception doit implémenter les constructeurs standard.

• Un constructeur public sans paramètre.
• Un constructeur public avec un seul argument de chaîne.
• Un constructeur public avec une chaîne et une exception (car il peut envelopper une autre exception).

• Un constructeur de sérialisation protégé si le type n'est pas scellé et privé si le type est scellé.Basé sur 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.
    }
  }  
  

ou

    [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

Vous pouvez également effectuer une vérification conditionnelle avec des paramètres dans le constructeur, ce qui permet une certaine flexibilité.

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

ou

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

Conformément à certaines des autres réponses répertoriées ici, vous pouvez transmettre des paramètres au constructeur de classe de base.Il est conseillé d'appeler le constructeur de votre classe de base au début du constructeur de votre classe héritée.

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

Je remarque que dans votre exemple vous n'avez jamais utilisé le extraInfo paramètre, j'ai donc supposé que vous voudriez peut-être concaténer le extraInfo paramètre de chaîne au Message propriété de votre exception (il semble que cela soit ignoré dans la réponse acceptée et le code de votre question).

Ceci est simplement réalisé en appelant le constructeur de classe de base, puis en mettant à jour la propriété Message avec les informations supplémentaires.

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