Miembros con cuerpo de expresión en C#

Los miembros con cuerpo de expresión proporcionan una sintaxis mínima y concisa para definir propiedades y métodos. Ayuda a eliminar el código repetitivo y ayuda a escribir código que sea más legible. La sintaxis con cuerpo de expresión se puede usar cuando el cuerpo de un miembro consiste solo en una expresión. Utiliza el operador => (f en la flecha ) para definir el cuerpo del método o la propiedad y permite deshacerse de las llaves y la palabra clave de retorno . La función se introdujo por primera vez en C# 6.

Métodos con cuerpo de expresión

En C#, un método es una colección de declaraciones que realizan una tarea determinada y devuelven el resultado a la persona que llama. Muchas veces, los métodos terminan conteniendo solo una declaración. Por ejemplo, considere el siguiente código:

int GetRectangleArea(int length, int breadth) 
{
    return length * breadth;
} 

El método anterior solo consta de una declaración de devolución única. Usando la sintaxis con cuerpo de expresión, el método anterior se puede reescribir de la siguiente manera:

int GetRectangleArea(int length, int breadth) => length * breadth;

Observe, la ausencia de las llaves y la declaración de devolución . En lugar de llaves, se ha utilizado el operador => . La expresión que sigue después de la declaración de devolución se escribe justo después del operador => .

Sintaxis

[modificador de acceso] [calificadores] tipo de retorno MethodName([parámetros]) => expresión;

Ejemplo

El siguiente ejemplo define un método booleano llamado IsEven() que devuelve verdadero si el número que se le pasa es par; de lo contrario, el método devuelve falso. El método IsEven() usa sintaxis con cuerpo de expresión.

// C# program to illustrate expression bodied method
using System;
  
class GFG{
      
// Returns true if number is even
// else returns false
public static bool IsEven(int number) => number % 2 == 0;
  
// Driver code
public static void Main()
{
    int n = 10;
      
    if (IsEven(n))
    {
          Console.WriteLine("{0} is even", n);
    }
    else 
    {
        Console.WriteLine("{0} is odd", n);
    }
}
}

10 is even

Métodos de vacío con cuerpo de expresión 

Los métodos vacíos son aquellos métodos que no contienen una declaración de retorno y consisten solo en una sola declaración, también pueden usar sintaxis con cuerpo de expresión. Por ejemplo, el siguiente método:

void PrintName(string name)
{
    Console.WriteLine($"The name is {name}");
}

se puede escribir con sintaxis con cuerpo de expresión de la siguiente manera:

void PrintName(string name) => Console.WriteLine($"The name is {name}"); 

Propiedades con cuerpo de expresión

Los accesores de propiedad también pueden tener solo una declaración. Con propiedades con cuerpo de expresión, tales definiciones de propiedad se pueden simplificar.

1. Propiedades de solo lectura

Las propiedades de solo lectura son propiedades que solo tienen un descriptor de acceso get , como el siguiente:

public int Name 
{ 
    get 
    {
        return "Geeks For Geeks";
    }
}  

Usando la sintaxis con cuerpo de expresión, la propiedad se puede definir de la siguiente manera:

public int Name => "Geeks For Geeks";

Sintaxis

[modificador de acceso] [calificador] type PropertyName => expresión;

Ejemplo

El siguiente ejemplo define una clase llamada Square con un constructor que acepta la longitud del lado del cuadrado. Una vez que se establece el lado en el constructor, no se puede modificar porque la propiedad pública Side es de solo lectura. Además, el campo lateral es privado y no se puede acceder desde fuera de la clase.

// C# program to illustrate expression bodied properties
using System;
  
public class Square 
{
    private int side;
    
    public Square(int side) 
    {
        this.side = side;
    }
      
    public int Side => side;
}
  
class GFG{
  
// Driver code
public static void Main()
{
    var square = new Square(4);
    Console.WriteLine($"Side is {square.Side}");
}
}

Side is 4

2. Propiedades de no solo lectura

Desde C# 7, las propiedades que no son de solo lectura también pueden tener descriptores de acceso get y set con cuerpo de expresión . En la siguiente clase Person , la propiedad Name define los accesores get y set , cada uno con una sola instrucción:

public class Person
{
    private string name;
    
    public string Name
    {
        get 
        {
            return name;
        }
        set 
        {
           name = value;
        }
    }
}

Esto se puede simplificar usando descriptores de acceso con cuerpo de expresión:

public class Person
{
    private string name;
    
    public string Name
    {
        get => name;
        set => name = value;
    }
}

Sintaxis

[modificador de acceso] [calificadores] [tipo] PropertyName

{

    obtener => expresión;

    conjunto => expresión;

}

Ejemplo

El siguiente código define una clase Square como el ejemplo anterior, pero aquí, la propiedad Side también tiene un descriptor de acceso establecido . Además, se ha utilizado un inicializador de objetos en lugar de un constructor para proporcionar el valor inicial de la propiedad Side :

// C# program to illustrate expression bodied properties
using System;
  
public class Square 
{
    private int side;
    
    public int Side 
    {
        get => side;
        set => side = value;
    }
}
  
class GFG{
  
// Driver code    
public static void Main()
{
    var square = new Square{Side = 4};
    Console.WriteLine($"Side is {square.Side}");
    square.Side = 10;
      Console.WriteLine($"Side is now {square.Side}");
}
}

Side is 4
Side is now 10

Constructores y destructores con cuerpo de expresión

La sintaxis con cuerpo de expresión también se ha ampliado para usarse con constructores y destructores/finalizadores . Si cualquiera de estos métodos contiene solo una declaración, se pueden definir como con cuerpo de expresión. 

Sintaxis

• Constructores

[modificador de acceso] ClassName([parámetros]) => expresión;

• Destructores/Finalizadores

~ClassName()=> expresión;

Ejemplo

En el siguiente ejemplo, la clase Square define un constructor y un destructor, cada uno de los cuales contiene una definición con cuerpo de expresión:

// C# program to illustrate expression-bodied 
// constructors and destructors
using System;
  
public class Square 
{
    private int side;
    
    public Square(int side) => this.side = side;
      
    ~Square() => Console.WriteLine("Square's Destructor");
    
    public int Side => side;
}
  
class GFG{
  
// Driver code
public static void Main()
{
    var square = new Square(4);
    Console.WriteLine($"Side is {square.Side}");
}
}

Side is 4
Square's Destructor

Indexadores con cuerpo de expresión

Al igual que las propiedades, los accesores de indexadores también pueden tener cuerpo de expresión. Las definiciones de indexador siguen las mismas convenciones que las propiedades, lo que implica que los indexadores de solo lectura se pueden definir sin especificar el acceso y los accesos de lectura y escritura requieren el nombre del acceso.

Sintaxis

• Indexadores de solo lectura

[modificador de acceso] [calificadores] return-type this[ [parámetros] ] => expresión;

• Indexadores de lectura y escritura

[modificador de acceso] [calificadores] return-type this [[parámetros]]

{

    obtener => expresión;

    conjunto => expresión;

}

Ejemplo

La siguiente clase ProgrammingLangs define un lenguaje de array de strings de lenguajes de programación y también define un indexador que reenvía los índices a la array de idiomas y devuelve el elemento (idioma) en ese índice. El indexador es de solo lectura, por lo que los idiomas de la array no se pueden modificar fuera de la clase.

// C# program to illustrate expression-bodied indexers
using System;
  
public class ProgrammingLangs
{
    private string[] languages = 
    {
        "C#",
        "C",
        "C++",
        "Python",
        "Java"
    };
    
    public string this[int idx] => languages[idx];
}
  
class GFG{
  
// Driver code
public static void Main()
{
    var langs = new ProgrammingLangs();
    Console.WriteLine(langs[0]);
      Console.WriteLine(langs[2]);
      Console.WriteLine(langs[3]);
}
}

C#
C++
Python

Funciones de operador con cuerpo de expresión

Al igual que los métodos ordinarios con una sola instrucción pueden tener un cuerpo de expresión, las definiciones de métodos de operadores también pueden tener un cuerpo de expresión si su cuerpo consta de una sola declaración.

Sintaxis

[modificador de acceso] operador estático [símbolo-operador] ([parámetros]) => expresión;

Ejemplo

El siguiente ejemplo implementa una clase Complex que representa la parte real e imaginaria de un número complejo y también define el operador binario + para permitir la suma de dos objetos Complex . La función operator+ tiene cuerpo de expresión.

// C# program to illustrate expression-bodied operator functions
using System;
  
public struct Complex
{
    public int Real{get; set;}
    public int Imaginary{get; set;}
    
    public Complex(int real, int imaginary)
    {
        Real = real;
        Imaginary = imaginary;
    }
     
    // Expression-bodied operator method
    public static Complex operator + (
        Complex c1, Complex c2) =>
        new Complex(c1.Real + c1.Real,
               c1.Imaginary + c2.Imaginary);
    
    public override string ToString() => 
       $"({Real}) + ({Imaginary}i)";
}
  
class GFG{
  
// Driver code 
public static void Main()
{
    var a = new Complex(3, 2);
    var b = new Complex(1, 2);
    var result = a + b;
      
    Console.WriteLine($"{a} + {b} = {result}");
}
}

Producción:

(3) + (2i) + (1) + (2i) = (6) + (4i)