C# Academy · Aula

Constantes e campos readonly

Diferencie const de static readonly.

Constantes e campos readonly é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 3 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.

Duas formas de tornar valores fixos

C# oferece const e readonly para valores que não devem mudar. Eles parecem semelhantes, mas se comportam de maneiras muito diferentes. Nesta lição, você comparará os dois.

using System;

class Config
{
    public const double Pi = 3.14159;
    public static readonly DateTime StartedAt = DateTime.Now;
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Pi = " + Config.Pi);
    }
}

const: constante em tempo de compilação

Um const deve receber um valor literal na declaração e é incorporado em tempo de compilação. Ele é implicitamente estático.

using System;

class Circle
{
    public const double Pi = 3.14159;

    public static double Area(double r) => Pi * r * r;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Circle.Area(2).ToString("0.00"));
    }
}

const deve ser um literal

Como é resolvido em tempo de compilação, um const só pode conter uma expressão constante: números, textos, valores booleanos ou outros const.

using System;

class Limits
{
    public const int MaxRetries = 3;
    public const int Timeout = MaxRetries * 1000;   // const expression OK
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Limits.MaxRetries + ", " + Limits.Timeout);
    }
}

readonly: constante em tempo de execução

Um campo readonly é definido uma vez, na declaração ou em um construtor, e não pode mais ser alterado. Seu valor pode ser calculado em tempo de execução.

using System;

class Session
{
    public readonly string Id;

    public Session(string id)
    {
        Id = id;   // allowed: inside constructor
    }
}

class Program
{
    static void Main()
    {
        var s = new Session("abc-123");
        Console.WriteLine("Session: " + s.Id);
    }
}

readonly pode usar valores de execução

Ao contrário de const, um campo readonly pode conter um valor que só é conhecido quando o programa é executado, como um identificador gerado ou o horário atual.

using System;

class Order
{
    public readonly Guid OrderId;

    public Order()
    {
        OrderId = Guid.NewGuid();
    }
}

class Program
{
    static void Main()
    {
        var o = new Order();
        Console.WriteLine("Has id: " + (o.OrderId != Guid.Empty));
    }
}

static readonly

Combine static readonly para obter um valor que abranja toda a classe e seja calculado uma vez em tempo de execução. Essa é a substituição usual para const quando o valor não é um literal.

using System;

class AppInfo
{
    public static readonly string[] Roles = { "admin", "user", "guest" };
}

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

    static int Roles() => AppInfo.Roles.Length;
}

Por que const pode ser arriscado entre conjuntos

Como os valores de const são inseridos no código chamador em tempo de compilação, alterar um const público em uma biblioteca exige recompilar todos os códigos que o chamam. static readonly evita isso.

using System;

class Lib
{
    public const int Version = 2;              // inlined into callers
    public static readonly int Build = 100;     // read at runtime
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Lib.Version + "." + Lib.Build);
    }
}

Nenhum dos dois pode ser reatribuído

Após a inicialização, nem um campo const nem um campo readonly pode ser alterado. Tentar fazer isso gera um erro de compilação.

using System;

class Demo
{
    public const int A = 10;
    public readonly int B;

    public Demo() { B = 20; }
    // A = 11;  // would not compile
    // B = 21;  // would not compile outside constructor
}

class Program
{
    static void Main()
    {
        var d = new Demo();
        Console.WriteLine(Demo.A + ", " + d.B);
    }
}

Escolhendo entre os dois

Use const para literais verdadeiros que nunca mudam (Pi, MaxInt). Use readonly quando o valor for calculado em tempo de execução ou puder variar entre instâncias.

using System;

class Physics
{
    public const double Gravity = 9.81;          // universal literal
    public readonly double Mass;                  // per object

    public Physics(double mass) { Mass = mass; }
    public double Weight() => Mass * Gravity;
}

class Program
{
    static void Main()
    {
        var p = new Physics(10);
        Console.WriteLine("Weight: " + p.Weight());
    }
}

Ressalva sobre referências readonly

readonly bloqueia o campo, não o objeto para o qual ele aponta. Uma referência readonly a uma lista não pode ser reatribuída, mas seu conteúdo ainda pode mudar.

using System;
using System.Collections.Generic;

class Cart
{
    public readonly List<string> Items = new List<string>();
}

class Program
{
    static void Main()
    {
        var c = new Cart();
        c.Items.Add("Pen");   // allowed: mutating the object
        c.Items.Add("Book");
        Console.WriteLine("Items: " + c.Items.Count);
    }
}

Reunindo tudo

Uma classe típica usa const para literais fixos e readonly para valores fixos por instância no momento da construção.

using System;

class Account
{
    public const decimal MinBalance = 0m;
    public readonly string Owner;

    public Account(string owner)
    {
        Owner = owner;
    }
}

class Program
{
    static void Main()
    {
        var a = new Account("Rin");
        Console.WriteLine(a.Owner + " min=" + Account.MinBalance);
    }
}

Verificação rápida

Teste sua compreensão de const e readonly.

Recapitulação

const é um literal definido em tempo de compilação, é implicitamente estático e é inserido nos códigos chamadores. readonly é definido uma vez na declaração ou em um construtor e pode usar valores de tempo de execução. Use const para literais verdadeiros, static readonly para valores compartilhados calculados em tempo de execução e lembre-se de que readonly bloqueia a referência, não o objeto.

using System;

class Demo
{
    public const int Max = 100;
    public readonly int Created;
    public Demo(int c) { Created = c; }
}

class Program
{
    static void Main()
    {
        var d = new Demo(7);
        Console.WriteLine(Demo.Max + ", " + d.Created);
    }
}

Perguntas Frequentes

A aula “Constantes e campos readonly” é grátis?

Sim — o texto completo de “Constantes e campos readonly” é 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 “Constantes e campos readonly”?

Diferencie const de static readonly. 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 3 de 4.

Quanto tempo leva a aula “Constantes e campos readonly”?

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