Usando Construtores (Guia de ProgramaÃ§Ã£o C#)

Artigo
08/25/2010

Construtores são Classe métodos que são executados quando um objeto de um determinado tipo é criado.Os construtores devem ter o mesmo nome que a classe, e geralmente inicializar os membros de dados do novo objeto.

No exemplo a seguir, uma classe nomeada Taxi é definida usando um construtor simples. Esta classe então é instanciado com o Novo operador.The Taxi construtor é invocado pela new operador imediatamente depois que a memória é alocada para o novo objeto.

public class Taxi
{
    public bool isInitialized;
    public Taxi()
    {
        isInitialized = true;
    }
}

class TestTaxi
{
    static void Main()
    {
        Taxi t = new Taxi();
        Console.WriteLine(t.isInitialized);
    }
}

É chamado um construtor sem parâmetros que leva um construtor padrão.Construtores padrão são invocados sempre que um objeto é instanciado, usando o new operador e sem argumentos são fornecidos para new. Para obter mais informações, consulte Construtores de instância (Guia de programação C#).

Classes sem construtores a menos que seja Estático, a classe recebem um construtor público padrão pelo compilador C# para habilitar instanciação de classe.Para obter mais informações, consulte Classes estáticas e membros de classe estáticos (guia de programação C#).

Você pode impedir que uma classe de sendo instanciado, tornando o construtor particular, da seguinte maneira:

class NLog
{
    // Private Constructor:
    private NLog() { }

    public static double e = Math.E;  //2.71828...
}

Para obter mais informações, consulte Construtores particular (guia de programação translation from VPE for Csharp).

Construtores para struct tipos se parecem com construtores de classe, mas structs não pode conter um construtor padrão explícita, pois é fornecida automaticamente pelo compilador. Esse construtor inicializa cada campo no struct os valores padrão. Para obter mais informações, consulte Tabela de valores padrão (translation from VPE for Csharp Reference).No entanto, esse construtor padrão é ocasionada somente se o struct é instanciado com new. Por exemplo, esse código usa o construtor padrão de Int32, para que você pode contar que o número inteiro é inicializado:

int i = new int();
Console.WriteLine(i);

No entanto, faz com que o código a seguir, CS0165 de erro do compilador porque ele não usa new, e porque ele tenta usar um objeto que não foi inicializado:

int i;
Console.WriteLine(i);

sistema autônomo alternativa, sistema autônomo objetos com base em structs (incluindo todos sistema autônomo tipos numéricos internos) pode ser inicializado ou atribuído e, em seguida, usado sistema autônomo no exemplo a seguir:

int a = 44;  // Initialize the value type...
int b;
b = 33;      // Or assign it before using it.
Console.WriteLine("{0}, {1}", a, b);

Portanto, chamar o construtor padrão para um tipo de valor não é necessário.

Classes e structs pode definir construtores que usam parâmetros. Construtores que usam parâmetros devem ser chamados por meio de um new demonstrativo ou uma base demonstrativo.Classes e structs também pode definir vários construtores e nenhuma é necessária para definir um construtor padrão. Por exemplo:

public class Employee
{
    public int salary;

    public Employee(int annualSalary)
    {
        salary = annualSalary;
    }

    public Employee(int weeklySalary, int numberOfWeeks)
    {
        salary = weeklySalary * numberOfWeeks;
    }
}

Essa classe pode ser criada usando uma das instruções a seguir:

Employee e1 = new Employee(30000);
Employee e2 = new Employee(500, 52);

Um construtor pode usar o base palavra-chave para chamar o construtor da classe base. Por exemplo:

public class Manager : Employee
{
    public Manager(int annualSalary)
        : base(annualSalary)
    {
        //Add further instructions here.
    }
}

Neste exemplo, o construtor para a classe base é chamado antes o bloco para o construtor é executado.The base palavra-chave pode ser usado com ou sem parâmetros. Todos sistema autônomo parâmetros para o construtor podem ser usados sistema autônomo parâmetros para base, ou sistema autônomo parte de uma expressão. Para obter mais informações, consulte Base (Referência C#).

Em uma classe derivada, se um construtor de classe base não for chamado explicitamente usando o base palavra-chave, o construtor padrão, se houver um, é chamado implicitamente. Isso significa que as seguintes declarações de construtor é efetivamente o mesmo:

public Manager(int initialdata)
{
    //Add further instructions here.
}

public Manager(int initialdata)
    : base()
{
    //Add further instructions here.
}

Se uma classe base não oferece um construtor padrão, a classe derivada deve fazer uma telefonar explícita para um construtor base usando base.

Um construtor pode chamar outro construtor no mesmo objeto, usando o Isso palavra-chave.sistema autônomo base, this pode ser usado com ou sem parâmetros, e quaisquer parâmetros no construtor estão disponível sistema autônomo parâmetros para this, ou sistema autônomo parte de uma expressão. Por exemplo, o segundo construtor no exemplo anterior pode ser reescrito usando this:

public Employee(int weeklySalary, int numberOfWeeks)
    : this(weeklySalary * numberOfWeeks)
{
}

O uso do this palavra-chave no exemplo anterior causa esse construtor deve ser chamado:

public Employee(int annualSalary)
{
    salary = annualSalary;
}

Constructors can be marked as public, private, protected, internal, or protectedinternal.Definir como usuários da classe podem construir a classe esses modificadores de acesso.Para obter mais informações, consulte Modificadores de acesso.

Um construtor pode ser declarado estático usando o estático palavra-chave.Construtores estático são chamados automaticamente, imediatamente antes que quaisquer campos estático são acessados e geralmente são usados para inicializar os membros da classe estática.Para obter mais informações, consulte Construtores estáticos.