C# Academy · Aula

Construtores estáticos

Inicialize o estado estático exatamente uma vez.

Construtores estáticos é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

O que é um construtor estático?

Um construtor estático inicializa dados estáticos de uma classe. Ele é executado automaticamente uma vez, antes que a classe seja usada pela primeira vez, e nunca é chamado diretamente por você.

using System;

class App
{
    public static string Version;

    static App()
    {
        Version = "1.0.0";
        Console.WriteLine("Static constructor ran");
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(App.Version);
    }
}

Regras de sintaxe

Um construtor estático usa a palavra-chave static, tem o nome da classe, não recebe parâmetros e não tem modificador de acesso.

using System;

class Config
{
    public static int MaxUsers;

    static Config()
    {
        MaxUsers = 100;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Max: " + Config.MaxUsers);
    }
}

Executado exatamente uma vez

Independentemente de quantas vezes você use a classe, o construtor estático é executado apenas uma vez, na primeira vez que for necessário.

using System;

class Counter
{
    public static int Instances;

    static Counter()
    {
        Console.WriteLine("Initializing static state");
        Instances = 0;
    }

    public Counter() { Instances++; }
}

class Program
{
    static void Main()
    {
        new Counter();
        new Counter();
        Console.WriteLine("Instances: " + Counter.Instances);
    }
}

Quando ele é acionado?

O ambiente de execução o chama imediatamente antes do primeiro acesso a qualquer membro estático OR da primeira criação de uma instância, o que ocorrer primeiro.

using System;

class Lazy
{
    public static string Data;

    static Lazy()
    {
        Console.WriteLine("Triggered now");
        Data = "ready";
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Before access");
        Console.WriteLine(Lazy.Data);
    }
}

Inicializando dados estáticos complexos

Use um construtor estático quando os campos estáticos precisarem de uma lógica real de configuração, e não apenas de literais simples.

using System;
using System.Collections.Generic;

class Lookup
{
    public static Dictionary<int, string> Table;

    static Lookup()
    {
        Table = new Dictionary<int, string>();
        for (int i = 1; i <= 3; i++)
            Table[i] = "Item" + i;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Lookup.Table[2]);
    }
}

Construtor estático versus inicializador de campo

Valores simples podem usar inicializadores embutidos. Um construtor estático é indicado para configurações que exigem instruções, loops ou tratamento de erros.

using System;

class Settings
{
    public static int Simple = 10;        // inline initializer
    public static int Computed;            // needs logic

    static Settings()
    {
        Computed = Simple * Simple;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Settings.Simple + ", " + Settings.Computed);
    }
}

Parâmetros não são permitidos

Como o ambiente de execução o chama para você, um construtor estático não pode aceitar argumentos. Todas as entradas dele devem ser outros dados estáticos ou constantes.

using System;

class Clock
{
    public static int StartHour;

    static Clock()
    {
        StartHour = 9;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Start: " + Clock.StartHour);
    }
}

Combinando construtores estáticos e de instância

Uma classe pode ter os dois tipos. O estático é executado uma vez para o tipo; o de instância é executado para cada objeto.

using System;

class Game
{
    public static string Title;
    public int Score;

    static Game()
    {
        Title = "Coddy Quest";
    }

    public Game(int score)
    {
        Score = score;
    }
}

class Program
{
    static void Main()
    {
        var g = new Game(50);
        Console.WriteLine(Game.Title + " score " + g.Score);
    }
}

Garantia de ordem

É garantido que o construtor estático termine antes da execução de qualquer corpo de construtor de instância que o acione, portanto o estado estático está sempre pronto.

using System;

class Service
{
    public static string Endpoint;

    static Service()
    {
        Endpoint = "https://api.example.com";
    }

    public Service()
    {
        Console.WriteLine("Using " + Endpoint);
    }
}

class Program
{
    static void Main()
    {
        new Service();
    }
}

Use com moderação

Construtores estáticos adicionam uma verificação única antes do uso da classe e podem prejudicar o desempenho se forem usados em excesso ou lançarem uma exceção. Mantenha-os pequenos e confiáveis.

using System;

class Cache
{
    public static int[] Data;

    static Cache()
    {
        Data = new int[] { 2, 4, 6, 8 };
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Cache.Data[3]);
    }
}

Reunindo tudo

Construtores estáticos são ideais para a configuração única de dados compartilhados e somente leitura, como tabelas de consulta ou configurações carregadas de constantes.

using System;
using System.Collections.Generic;

class Currency
{
    public static Dictionary<string, string> Symbols;

    static Currency()
    {
        Symbols = new Dictionary<string, string>
        {
            ["USD"] = "$",
            ["EUR"] = "E",
            ["JPY"] = "Y"
        };
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("USD symbol: " + Currency.Symbols["USD"]);
    }
}

Verificação rápida

Teste sua compreensão sobre construtores estáticos.

Recapitulação

Um construtor estático usa static ClassName(), sem parâmetros e sem modificador de acesso. Ele é executado uma vez, automaticamente, antes que a classe seja usada pela primeira vez, para inicializar um estado estático que exige lógica real. Use-o com moderação para a configuração única de dados compartilhados.

using System;

class Demo
{
    public static int Value;
    static Demo() { Value = 42; }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Demo.Value);
    }
}

Perguntas Frequentes

A aula “Construtores estáticos” é grátis?

Sim — o texto completo de “Construtores estáticos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Construtores estáticos”?

Inicialize o estado estático exatamente uma vez. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Construtores estáticos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C# Academy