0Pricing
C# Academy · Aula

Design estático versus de instância

Decida quando o estado estático é apropriado.

Design estático versus de instância é 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.

Uma decisão de design

Escolher entre estático e instância é uma decisão de design. A pergunta principal é: o comportamento depende do estado de cada objeto ou apenas de suas entradas?

using System;

class Program
{
    // Depends only on inputs -> good static method
    static int Max(int a, int b) => a > b ? a : b;

    static void Main()
    {
        Console.WriteLine(Max(3, 8));
    }
}

Use o estático para lógica sem estado

Se um método não precisar de campos da instância e apenas transformar entradas, torne-o static. Auxiliares matemáticos e formatadores são exemplos ideais.

using System;

static class Convert2
{
    public static double MilesToKm(double miles) => miles * 1.60934;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Convert2.MilesToKm(10).ToString("0.0") + " km");
    }
}

Use instâncias para manter estado

Se o comportamento depender de dados que variam entre objetos, use uma instância. Cada objeto mantém seu próprio estado.

using System;

class Counter
{
    private int _count;
    public void Increment() => _count++;
    public int Value => _count;
}

class Program
{
    static void Main()
    {
        var a = new Counter();
        var b = new Counter();
        a.Increment();
        a.Increment();
        b.Increment();
        Console.WriteLine("a=" + a.Value + ", b=" + b.Value);
    }
}

Estado compartilhado é estado global

Um campo estático é, na prática, global. Ele pode causar erros sutis quando várias partes de um programa o leem e escrevem. Prefira o estado de instância quando cada usuário precisar de sua própria cópia.

using System;

class BadCart
{
    public static int Items;   // shared by EVERYONE -> usually wrong for a cart
}

class Program
{
    static void Main()
    {
        BadCart.Items++;
        BadCart.Items++;
        Console.WriteLine("All carts share: " + BadCart.Items);
    }
}

Facilidade de teste

Métodos estáticos puros são fáceis de testar: a mesma entrada produz a mesma saída. No entanto, o estado estático mutável vaza entre os testes e os torna frágeis.

using System;

static class Calc
{
    public static int Add(int a, int b) => a + b;   // trivially testable
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Calc.Add(2, 2) == 4 ? "pass" : "fail");
    }
}

Estático para auxiliares de fábrica

Métodos de fábrica estáticos são uma forma clara de criar instâncias configuradas com um nome descritivo.

using System;

class Color
{
    public int R, G, B;
    private Color(int r, int g, int b) { R = r; G = g; B = b; }

    public static Color Red() => new Color(255, 0, 0);
    public static Color White() => new Color(255, 255, 255);
}

class Program
{
    static void Main()
    {
        var c = Color.Red();
        Console.WriteLine(c.R + "," + c.G + "," + c.B);
    }
}

Evite o estático apenas para não usar new

Não torne tudo estático apenas para evitar a criação de objetos. Se um tipo representar algo com estado, as instâncias manterão esse estado isolado e seguro.

using System;

class Player
{
    public string Name;
    public int Health = 100;
    public void TakeDamage(int d) => Health -= d;
}

class Program
{
    static void Main()
    {
        var p1 = new Player { Name = "A" };
        var p2 = new Player { Name = "B" };
        p1.TakeDamage(30);
        Console.WriteLine(p1.Name + ": " + p1.Health + ", " + p2.Name + ": " + p2.Health);
    }
}

Combinando ambos adequadamente

Muitas classes usam membros estáticos para constantes ou contadores compartilhados e membros de instância para dados específicos de cada objeto. Essa combinação é perfeitamente idiomática.

using System;

class Invoice
{
    private static int _seq = 1000;
    public readonly int Number;
    public decimal Amount;

    public Invoice(decimal amount)
    {
        Number = _seq++;
        Amount = amount;
    }
}

class Program
{
    static void Main()
    {
        var i1 = new Invoice(50m);
        var i2 = new Invoice(75m);
        Console.WriteLine(i1.Number + " / " + i2.Number);
    }
}

Questão de concorrência

Várias threads podem acessar o estado estático compartilhado ao mesmo tempo, o que pode causar condições de corrida. O estado de instância confinado a uma única thread é mais seguro por padrão.

using System;

class SafeCalc
{
    // No shared mutable state -> naturally thread-safe
    public static long Factorial(int n)
    {
        long result = 1;
        for (int i = 2; i <= n; i++) result *= i;
        return result;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(SafeCalc.Factorial(5));
    }
}

Uma regra prática simples

Estático = comportamento que pertence ao tipo e não usa estado específico de um objeto. Instância = comportamento que lê ou altera um objeto específico. Em caso de dúvida, prefira uma instância para tudo que tiver estado.

using System;

class Temperature
{
    public double Celsius;                                  // instance state
    public static double ToF(double c) => c * 9 / 5 + 32;   // stateless helper
}

class Program
{
    static void Main()
    {
        var t = new Temperature { Celsius = 30 };
        Console.WriteLine(Temperature.ToF(t.Celsius));
    }
}

Reunindo tudo

Um bom design separa os auxiliares sem estado (estáticos) dos modelos com estado (instâncias), mantendo o estado mutável compartilhado em um mínimo deliberado.

using System;

static class TaxRules
{
    public static decimal Apply(decimal amount, decimal rate) => amount + amount * rate;
}

class Sale
{
    public decimal Subtotal;
    public decimal Total(decimal rate) => TaxRules.Apply(Subtotal, rate);
}

class Program
{
    static void Main()
    {
        var s = new Sale { Subtotal = 100m };
        Console.WriteLine(s.Total(0.2m));
    }
}

Verificação rápida

Teste sua compreensão sobre o design estático e de instância.

Recapitulação

Escolha estático para lógica sem estado que dependa apenas das entradas (auxiliares, fábricas, constantes) e instância para comportamentos associados ao estado de cada objeto. O estado estático mutável é, na prática, global, mais difícil de testar e sujeito a erros de concorrência; portanto, mantenha-o mínimo e deliberado.

using System;

static class Util { public static int Sq(int n) => n * n; }

class Box { public int Size; public int Area() => Util.Sq(Size); }

class Program
{
    static void Main()
    {
        var box = new Box { Size = 4 };
        Console.WriteLine(box.Area());
    }
}

Perguntas Frequentes

A aula “Design estático versus de instância” é grátis?

Sim — o texto completo de “Design estático versus de instância” é 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 “Design estático versus de instância”?

Decida quando o estado estático é apropriado. 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 “Design estático versus de instância”?

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

  1. Métodos e campos estáticos
  2. Classes estáticas para utilitários
  3. Constantes e campos readonly
  4. Design estático versus de instância
← Voltar para C# Academy