0Pricing
C# Academy · Lección

Miembros cuyo cuerpo es una expresión

Escriba propiedades y métodos compactos.

Miembros cuyo cuerpo es una expresión es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

Una sintaxis más concisa

La sintaxis de cuerpo de expresión utiliza => para definir un miembro como una sola expresión, en lugar de un cuerpo completo { ... }. Hace que los miembros breves sean compactos y fáciles de leer.

using System;

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

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

Métodos con cuerpo de expresión

Cualquier método cuyo cuerpo sea una sola expresión puede utilizar =>. El resultado de la expresión se convierte en el valor devuelto.

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));
    }
}

Propiedades de solo lectura con cuerpo de expresión

Una propiedad calculada de solo lectura puede utilizar => en lugar 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 y set con cuerpo de expresión

También puede proporcionar a los accesores get y set sus propios cuerpos de expresión, lo que resulta útil con un campo de respaldo.

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 + "]");
    }
}

Devolver cadenas calculadas

Las propiedades con cuerpo de expresión resultan ideales para valores formateados y derivados, como nombres completos o etiquetas.

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);
    }
}

Cuerpos de expresión con condiciones

La expresión única puede incluir un operador condicional (ternario), manteniendo la lógica de bifurcación en una sola línea.

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 con cuerpo de expresión

Un método que realiza una acción y no devuelve nada también puede tener un cuerpo de expresión si la acción consta de una sola instrucción.

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");
    }
}

Constructores con cuerpo de expresión

Un constructor con una sola asignación también puede utilizar la sintaxis de flecha.

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);
    }
}

Cuándo NO usarla

Los cuerpos de expresión solo sirven para una sola expresión. Si necesita varias instrucciones, bucles o ramas de validación, utilice un cuerpo de bloque 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));
    }
}

Combinar varios en una clase

Una clase pequeña puede utilizar la sintaxis de flecha para casi todos sus miembros, reduciendo considerablemente el 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");
    }
}

Integrarlo todo

Utilice miembros con cuerpo de expresión para mantener limpios los getters sencillos, los métodos auxiliares y los métodos de una sola línea, y reserve los cuerpos de bloque para la 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);
    }
}

Comprobación rápida

Compruebe cuánto ha aprendido sobre los miembros con cuerpo de expresión.

Resumen

Los miembros con cuerpo de expresión utilizan => para definir un miembro mediante una sola expresión. Funcionan con métodos, propiedades de solo lectura, accesores get/set individuales e incluso constructores. Utilícelos para expresiones concisas de una sola línea; cambie a un cuerpo de bloque cuando necesite varias instrucciones.

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);
    }
}

Preguntas frecuentes

¿La lección «Miembros cuyo cuerpo es una expresión» es gratis?

Sí — el texto completo de «Miembros cuyo cuerpo es una expresión» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Miembros cuyo cuerpo es una expresión»?

Escriba propiedades y métodos compactos. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Miembros cuyo cuerpo es una expresión»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Propiedades implementadas automáticamente
  2. Propiedades completas con campos de respaldo
  3. Miembros cuyo cuerpo es una expresión
  4. Indexadores
← Volver a C# Academy