static em C#: classes, métodos, campos e construtores static

static marca um membro que pertence ao tipo, não a um objeto. Um campo de instância existe uma vez por objeto; um campo static existe uma vez, e pronto. Um método de instância executa em um objeto (order.Ship()); um método static executa no tipo (Math.Round(x)) e não precisa de objeto nenhum.

Campos static: uma cópia, compartilhada

A forma mais clara de ver a diferença é um contador. Cada Order tem o seu próprio Id, mas a contagem de pedidos criados até agora precisa ficar em algum lugar compartilhado.

using System;

class Order
{
    private static int created;   // one copy for the whole program
    public int Id { get; }        // one copy per order
    public string Customer { get; }

    public Order(string customer)
    {
        created++;
        Id = created;
        Customer = customer;
    }

    public static int Created => created;
}

class Program
{
    static void Main()
    {
        var a = new Order("Ana");
        var b = new Order("Ben");
        var c = new Order("Chen");

        Console.WriteLine($"{a.Customer} #{a.Id}, {b.Customer} #{b.Id}, {c.Customer} #{c.Id}");
        Console.WriteLine($"Orders created: {Order.Created}");
    }
}

Saída:

Ana #1, Ben #2, Chen #3
Orders created: 3

Membros static são acessados pelo nome do tipo: Order.Created, não a.Created. C# não permite chegar a um membro static por meio de uma instância (erro CS0176), o que deixa óbvio, no ponto da chamada, que o valor é compartilhado.

Métodos static

Um método static não tem this. Ele trabalha com os parâmetros e só com outros membros static. Isso o torna a forma natural para auxiliares que calculam algo a partir das entradas:

using System;

class Pricing
{
    public static decimal WithVat(decimal net, decimal rate) => Math.Round(net * (1 + rate), 2);

    public static string Format(decimal amount) => amount.ToString("0.00") + " EUR";
}

class Program
{
    static void Main()
    {
        decimal gross = Pricing.WithVat(49.90m, 0.23m);
        Console.WriteLine(Pricing.Format(gross));
        Console.WriteLine(Math.Max(3, 7)); // Math is full of static methods
    }
}

Saída:

61.38 EUR
7

O próprio Main é static: o runtime o chama antes de existir qualquer objeto.

O erro CS0120: código static usando membros de instância

Como o Main é static, iniciantes muitas vezes esbarram nesse erro assim que adicionam um segundo método:

class Program
{
    int visits;
    void Greet() { Console.WriteLine("Hello"); }

    static void Main()
    {
        Greet();    // error CS0120: An object reference is required for the non-static field, method, or property 'Program.Greet()'
        visits++;   // error CS0120: An object reference is required for the non-static field, method, or property 'Program.visits'
    }
}

Um método static não tem objeto, então não existe um visits para ele incrementar. Duas soluções, e a certa depende do que o membro é:

• O membro realmente é um dado por objeto: crie um objeto e use-o. var app = new Program(); app.Greet();
• O membro não precisa de estado de objeto: marque-o como static. static void Greet() { ... }

Marcar tudo como static para o erro sumir funciona em um programa minúsculo e vira estado global em um programa real. Decida perguntando se o dado pertence a um objeto ou ao programa inteiro.

A direção inversa é sempre permitida: métodos de instância podem chamar membros static à vontade.

Classes static

Uma classe declarada como static só pode conter membros static e nunca pode ser instanciada. Ela é um grupo com nome de funções e constantes.

using System;

static class Temperature
{
    public const decimal FreezingC = 0m;

    public static decimal ToFahrenheit(decimal c) => c * 9 / 5 + 32;
    public static decimal ToCelsius(decimal f) => (f - 32) * 5 / 9;
    public static bool IsFreezing(decimal c) => c <= FreezingC;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Temperature.ToFahrenheit(25m));
        Console.WriteLine(Temperature.ToCelsius(212m));
        Console.WriteLine(Temperature.IsFreezing(-3m));
        // var t = new Temperature(); // error CS0712: Cannot create an instance of the static class 'Temperature'
    }
}

Saída:

77
100
True

O compilador garante o contrato: um membro de instância dentro de uma classe static é o erro CS0708, e new nela é o erro CS0712. Math, Console, File, Path e Enumerable são todas classes static. Métodos de extensão também precisam ficar em uma classe static.

Construtores static e static readonly

Um campo static cujo valor precisa de mais que uma expressão pode ser definido em um construtor static, que o runtime executa uma vez, antes de o tipo ser usado pela primeira vez:

using System;
using System.Collections.Generic;

class ShippingRates
{
    public static readonly IReadOnlyDictionary<string, decimal> ByCountry;
    public static readonly DateTime LoadedOn = new DateTime(2026, 1, 1);

    static ShippingRates()
    {
        Console.WriteLine("ShippingRates initialized");
        ByCountry = new Dictionary<string, decimal> { ["PT"] = 4.90m, ["ES"] = 5.50m, ["FR"] = 6.20m };
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Before first use");
        Console.WriteLine(ShippingRates.ByCountry["ES"]);
        Console.WriteLine(ShippingRates.ByCountry.Count);
        Console.WriteLine(ShippingRates.LoadedOn.ToString("yyyy-MM-dd"));
    }
}

Saída:

Before first use
ShippingRates initialized
5.50
3
2026-01-01

readonly significa que o campo só pode ser atribuído no inicializador ou no construtor static. Depois disso ele não pode ser reatribuído, embora o objeto para o qual aponta ainda possa ser mutável, e é por isso que o dicionário é exposto como IReadOnlyDictionary.

const vs static readonly

Os dois dão um valor com nome compartilhado pelo programa inteiro, e diferem no momento em que o valor é fixado:

A linha da cópia importa para bibliotecas: se o assembly A declara public const int MaxItems = 50; e o assembly B o usa, B contém o literal 50. Mudar A para 100 não faz nada por B até B ser recompilado. Para valores que podem mudar entre versões, prefira static readonly.

using static

Uma diretiva using static (C# 6) importa os membros static de um tipo, para que você possa chamá-los sem o nome do tipo:

using System;
using static System.Math;
using static System.Console;

class Program
{
    static void Main()
    {
        double radius = 3;
        double area = PI * Pow(radius, 2);
        WriteLine($"Area: {area:F2}");
        WriteLine(Max(12, 40));
    }
}

Saída:

Area: 28.27
40

Ela se lê bem em código com muita matemática. Use com moderação em outros lugares: um WriteLine ou Parse solto esconde de que tipo o método vem.

Estado static e threads

Um campo static é compartilhado por todas as threads do processo. Incrementá-lo a partir de várias threads ao mesmo tempo perde atualizações, porque created++ é uma leitura, uma soma e uma escrita, e duas threads podem intercalar esses passos. Use Interlocked.Increment(ref created) para contadores, ou um lock para qualquer coisa maior. Aplicações web são o lugar onde isso costuma morder: cada requisição executa em alguma thread, então um campo static que guarda "o usuário atual" é compartilhado por todos os usuários.

Mais uma sutileza: em uma classe genérica, cada tipo construído tem os próprios campos static. Cache<int>.Count e Cache<string>.Count são dois campos diferentes.

Quando usar static

Bons usos:

• Auxiliares puros que calculam um resultado a partir dos argumentos: formatação, conversões, validação.
• Constantes e dados de consulta somente leitura compartilhados pelo programa.
• Métodos de fábrica, como TimeSpan.FromMinutes(5) ou o seu próprio Temperature.FromCelsius(21).
• Métodos de extensão.

Maus usos:

• Estado global mutável (o usuário atual, um carrinho de compras, configurações que mudam). Ele acopla todo código que mexe nele e faz os testes dependerem das sobras uns dos outros.
• Qualquer coisa que você vá querer trocar nos testes, como um relógio, um banco de dados ou um enviador de e-mail. Chamadas static não podem ser substituídas por uma versão falsa; uma instância passada ao construtor pode.