overload - how to instance a class in c#




Chamando o construtor de base em c# (7)

É verdade usar a base (alguma coisa) para chamar o construtor da classe base, mas em caso de sobrecarga use a palavra this chave 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

Se eu herdar de uma classe base e quiser passar algo do construtor da classe herdada para o construtor da classe base, como faço isso?

Por exemplo,

Se eu herdar da classe Exception, quero fazer algo assim:

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

Basicamente, o que eu quero é poder passar a mensagem de string para a classe Exception base.


De acordo com algumas das outras respostas listadas aqui, você pode passar parâmetros para o construtor da classe base. É aconselhável chamar seu construtor de classe base no início do construtor para sua classe herdada.

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

Eu extraInfo que em seu exemplo você nunca fez uso do parâmetro extraInfo , então eu assumi que você poderia querer concatenar o parâmetro de string extraInfo para a propriedade Message de sua exceção (parece que isto está sendo ignorado na resposta aceita eo código em sua pergunta).

Isso é conseguido simplesmente chamando o construtor da classe base e atualizando a propriedade Message com a informação extra.

Como alternativa, como a propriedade Message é herdada da classe base, você nem precisa chamar o construtor da classe base explicitamente. Você pode apenas atualizar a propriedade Message diretamente do construtor de sua classe herdada, desta forma:

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

Observe que você pode usar métodos estáticos dentro da chamada para o construtor 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;
     }
}

Se você precisar chamar o construtor de base, mas não imediatamente, porque sua nova classe (derivada) precisa fazer alguma manipulação de dados, a melhor solução é recorrer ao método de fábrica. O que você precisa fazer é marcar seu construtor derivado, em seguida, fazer um método estático em sua classe que fará todas as coisas necessárias e depois chamar o construtor e retornar o objeto.

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

Das diretrizes do Framework Design e das regras do FxCop. :

1. A exceção personalizada deve ter um nome que termine com Exceção

    class MyException : Exception

2. A exceção deve ser pública

    public class MyException : Exception

3. CA1032: A exceção deve implementar construtores padrão.

  • Um construtor público sem parâmetros.
  • Um construtor público com um argumento de string.
  • Um construtor público com uma string e Exception (como ele pode envolver outra exceção).
  • Um construtor de serialização protegido se o tipo não for selado e privado se o tipo for selado. Baseado no 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
    }
}

Você pode passar uma exceção interna para um dos construtores.







constructor