0Pricing
C# Academy · Aula

Membros com corpo de expressão

Escreva propriedades e métodos compactos.

Membros com corpo de expressão é 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.

Uma sintaxe mais concisa

A sintaxe de corpo de expressão usa => para definir um membro como uma única expressão, substituindo um corpo completo { ... }. Ela torna os membros curtos mais compactos e legíveis.

using System;

class Greeter
{
    public string Hello() => "Hi there!";
}

class Program
{
    static void Main()
    {
        var g = new Greeter();
        Console.WriteLine(g.Hello());
    }
}

Métodos com corpo de expressão

Qualquer método cujo corpo seja uma única expressão pode usar =>. O resultado da expressão se torna o valor de retorno.

using System;

class MathHelper
{
    public int Square(int x) => x * x;
    public int Add(int a, int b) => a + b;
}

class Program
{
    static void Main()
    {
        var m = new MathHelper();
        Console.WriteLine(m.Square(6));
        Console.WriteLine(m.Add(3, 4));
    }
}

Propriedades somente para leitura com corpo de expressão

Uma propriedade calculada somente para leitura pode usar => em vez de get { return ...; }.

using System;

class Rectangle
{
    public double Width { get; set; }
    public double Height { get; set; }
    public double Area => Width * Height;
}

class Program
{
    static void Main()
    {
        var r = new Rectangle { Width = 4, Height = 5 };
        Console.WriteLine("Area: " + r.Area);
    }
}

get e set com corpo de expressão

O senhor também pode fornecer aos acessadores get e set seus próprios corpos de expressão, o que é útil com um campo de suporte.

using System;

class Person
{
    private string _name;
    public string Name
    {
        get => _name;
        set => _name = value.Trim();
    }
}

class Program
{
    static void Main()
    {
        var p = new Person();
        p.Name = "  Niki  ";
        Console.WriteLine("[" + p.Name + "]");
    }
}

Retornando textos calculados

As propriedades com corpo de expressão são ideais para valores derivados e formatados, como nomes completos ou rótulos.

using System;

class Customer
{
    public string First { get; set; }
    public string Last { get; set; }
    public string Display => First + " " + Last;
}

class Program
{
    static void Main()
    {
        var c = new Customer { First = "Ada", Last = "Lovelace" };
        Console.WriteLine(c.Display);
    }
}

Corpos de expressão com condições

A expressão única pode incluir um operador condicional (ternário), mantendo a lógica de ramificação em uma linha.

using System;

class Account
{
    public decimal Balance { get; set; }
    public string Status => Balance >= 0 ? "OK" : "Overdrawn";
}

class Program
{
    static void Main()
    {
        var a = new Account { Balance = -20m };
        Console.WriteLine(a.Status);
    }
}

Métodos void com corpo de expressão

Um método que executa uma ação (não retorna nada) também pode ter corpo de expressão se a ação for uma única instrução.

using System;

class Logger
{
    public void Log(string msg) => Console.WriteLine("[LOG] " + msg);
}

class Program
{
    static void Main()
    {
        var log = new Logger();
        log.Log("Started");
    }
}

Construtores com corpo de expressão

Um construtor com uma atribuição pode usar também a sintaxe de seta.

using System;

class Point
{
    public int X { get; }
    public Point(int x) => X = x;
}

class Program
{
    static void Main()
    {
        var p = new Point(7);
        Console.WriteLine("X = " + p.X);
    }
}

Quando não usar NOT

Os corpos de expressão servem apenas para expressões únicas. Se o senhor precisar de várias instruções, laços ou ramificações de validação, use um corpo de bloco normal.

using System;

class Calculator
{
    // Single expression -> arrow is fine
    public int Triple(int n) => n * 3;

    // Multiple statements -> use a block
    public int SumTo(int n)
    {
        int total = 0;
        for (int i = 1; i <= n; i++) total += i;
        return total;
    }
}

class Program
{
    static void Main()
    {
        var c = new Calculator();
        Console.WriteLine(c.Triple(4));
        Console.WriteLine(c.SumTo(5));
    }
}

Combinando vários membros em uma classe

Uma classe pequena pode usar a sintaxe de seta em quase todos os membros, reduzindo drasticamente o código repetitivo.

using System;

class Temperature
{
    public double Celsius { get; set; }
    public double Fahrenheit => Celsius * 9 / 5 + 32;
    public double Kelvin => Celsius + 273.15;
    public override string ToString() => Celsius + "C";
}

class Program
{
    static void Main()
    {
        var t = new Temperature { Celsius = 25 };
        Console.WriteLine(t + " = " + t.Fahrenheit + "F = " + t.Kelvin + "K");
    }
}

Reunindo tudo

Use membros com corpo de expressão para manter acessadores de leitura simples, auxiliares e métodos de uma linha organizados, reservando os corpos de bloco para lógica real.

using System;

class Order
{
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal Total => Quantity * UnitPrice;
    public bool IsLarge => Quantity > 10;
}

class Program
{
    static void Main()
    {
        var o = new Order { Quantity = 12, UnitPrice = 9.99m };
        Console.WriteLine("Total: " + o.Total + ", Large: " + o.IsLarge);
    }
}

Verificação rápida

Teste sua compreensão sobre membros com corpo de expressão.

Recapitulação

Os membros com corpo de expressão usam => para definir um membro com uma única expressão. Eles funcionam para métodos, propriedades somente para leitura, acessadores get/set individuais e até construtores. Use-os para instruções concisas de uma linha; passe para um corpo de bloco sempre que precisar de várias instruções.

using System;

class Demo
{
    public int N { get; set; }
    public int Doubled => N * 2;
    public string Label() => "N is " + N;
}

class Program
{
    static void Main()
    {
        var d = new Demo { N = 9 };
        Console.WriteLine(d.Label() + ", doubled = " + d.Doubled);
    }
}

Perguntas Frequentes

A aula “Membros com corpo de expressão” é grátis?

Sim — o texto completo de “Membros com corpo de expressão” é 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 “Membros com corpo de expressão”?

Escreva propriedades e métodos compactos. 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 “Membros com corpo de expressão”?

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. Propriedades implementadas automaticamente
  2. Propriedades completas com campos de suporte
  3. Membros com corpo de expressão
  4. Indexadores
← Voltar para C# Academy