exemple - list c#




Appel du constructeur de base en C# (7)

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

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

Si j'hérite d'une classe de base et que je veux passer quelque chose du constructeur de la classe héritée au constructeur de la classe de base, comment puis-je faire cela?

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 est de pouvoir passer le message de chaîne à la classe d'exception de base.


Modifiez votre constructeur à ce qui 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 n'importe quand dans une méthode. C'est la raison pour laquelle vous obtenez des erreurs dans votre appel dans le corps du constructeur.


Selon certaines des autres réponses listées ici, vous pouvez passer des paramètres dans le constructeur de la classe de base. Il est conseillé d'appeler votre constructeur de classe de base au début du constructeur pour votre classe héritée.

public class MyException : Exception
{
    public MyException(string message, string extraInfo) : base(message)
    {
        this.Message = $"{message} Extra info: {extraInfo}";
        // You can omit the 'this.' portion above...
    }
}

Je note que dans votre exemple vous n'avez jamais utilisé le paramètre extraInfo , donc j'ai supposé que vous pourriez vouloir concaténer le paramètre de chaîne extraInfo à la propriété Message de votre exception (il semble que ceci soit ignoré dans la réponse acceptée et le code dans ta question).

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

Sinon, comme la propriété Message est héritée de la classe de base, vous n'avez même pas besoin d'appeler explicitement le constructeur de la classe de base. Vous pouvez simplement mettre à jour la propriété Message directement du constructeur de votre classe héritée, comme ceci:

public class MyException : Exception
{
    public MyException(string message, string extraInfo)
    {
        this.Message = $"{message} Extra info: {extraInfo}";
        // You can omit the 'this.' portion above...
    }
}

Si vous devez appeler le constructeur de base mais pas tout de suite parce que votre nouvelle classe (dérivée) a besoin de manipuler des données, la meilleure solution est de recourir à la méthode usine. Ce que vous devez faire est de marquer votre constructeur dérivé privé, puis faire une méthode statique dans votre classe qui fera tout le nécessaire et ensuite appeler le constructeur et retourner 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);
    }
}

A partir des directives de conception du cadre et des règles FxCop. :

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

    class MyException : Exception

2. L'exception devrait être publique

    public class MyException : Exception

3. CA1032: Exception doit implémenter des constructeurs standard.

  • Un constructeur public sans paramètre.
  • Un constructeur public avec un 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 est 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.
      }
    }  

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

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





constructor