C# Expression Bodies

Expression-Bodied Members provide a concise syntax for implementing members of a class or struct that consist of a single expression. Introduced in C# 6.0 and expanded in later versions, they enhance code readability and reduce boilerplate, making the codebase cleaner and more maintainable.

Table of Contents

1. Introduction to Expression-Bodied Members
- What are Expression-Bodied Members?
- History and Evolution
- Benefits of Using Expression-Bodied Members

2. Syntax of Expression-Bodied Members
- Expression-Bodied Methods
- Expression-Bodied Properties
- Expression-Bodied Constructors
- Expression-Bodied Finalizers
- Expression-Bodied Operators

3. Examples
- Methods
- Properties
- Constructors
- Finalizers
- Operators

4. Advantages
- Conciseness
- Improved Readability
- Reduced Boilerplate

5. Limitations
- Complexity of Expressions
- Debugging Challenges
- Compatibility with Older C# Versions

6. Best Practices
- When to Use Expression-Bodied Members
- Keeping Expressions Simple
- Consistent Coding Style

7. Common Mistakes
- Overcomplicating Expressions
- Ignoring Readability
- Misusing in Complex Scenarios

8. Advanced Topics
- Combining with Other C# Features
- Expression-Bodied Members in Interfaces
- Lambda Expressions vs. Expression-Bodied Members

9. Real-World Example
- Scenario
- Implementation
- Explanation

10. Summary

1. Introduction to Expression-Bodied Members

What are Expression-Bodied Members?

History and Evolution

Benefits of Using Expression-Bodied Members

2. Syntax of Expression-Bodied Members

Expression-Bodied Methods

returnType MethodName(parameters) => expression;

public class Calculator
{
    public int Add(int a, int b) => a + b;
}

Expression-Bodied Properties

public returnType PropertyName => expression;

public returnType PropertyName
{
    get => expression;
    set => field = value;
}

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

Expression-Bodied Constructors

public ClassName(parameters) => expression;

public class Person
{
    public string Name { get; }
    public int Age { get; }
    
    public Person(string name, int age) => (Name, Age) = (name, age);
}

Expression-Bodied Finalizers

~ClassName() => expression;

public class ResourceHolder
{
    // Finalizer using expression-bodied member
    ~ResourceHolder() => Dispose();
    
    private void Dispose()
    {
        // Cleanup resources
    }
}

Expression-Bodied Operators

public static returnType operator OPERATOR(parameters) => expression;

public class Complex
{
    public double Real { get; }
    public double Imaginary { get; }
    
    public Complex(double real, double imaginary)
    {
        Real = real;
        Imaginary = imaginary;
    }
    
    // Overloading the '+' operator using expression-bodied member
    public static Complex operator +(Complex a, Complex b) => 
        new Complex(a.Real + b.Real, a.Imaginary + b.Imaginary);
}

3. Examples

Expression-Bodied Methods

public class MathOperations
{
    public int Square(int number) => number * number;
}

class Program
{
    static void Main()
    {
        MathOperations math = new MathOperations();
        int result = math.Square(5);
        Console.WriteLine($"Square of 5 is {result}"); // Output: Square of 5 is 25
    }
}

Expression-Bodied Properties

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

class Program
{
    static void Main()
    {
        Rectangle rect = new Rectangle { Width = 5, Height = 4 };
        Console.WriteLine($"Area: {rect.Area}"); // Output: Area: 20
    }
}

public class Person
{
    private string firstName;
    private string lastName;
    
    public string FirstName
    {
        get => firstName;
        set => firstName = value.Trim();
    }
    
    public string LastName
    {
        get => lastName;
        set => lastName = value.Trim();
    }
    
    public string FullName => $"{FirstName} {LastName}";
}

class Program
{
    static void Main()
    {
        Person person = new Person();
        person.FirstName = " Alice ";
        person.LastName = " Smith ";
        Console.WriteLine($"Full Name: {person.FullName}"); // Output: Full Name: Alice Smith
    }
}

Expression-Bodied Constructors

public class Book
{
    public string Title { get; }
    public string Author { get; }
    
    public Book(string title, string author) => (Title, Author) = (title, author);
}

class Program
{
    static void Main()
    {
        Book book = new Book("1984", "George Orwell");
        Console.WriteLine($"{book.Title} by {book.Author}"); // Output: 1984 by George Orwell
    }
}

Expression-Bodied Finalizers

public class FileHandler
{
    private readonly FileStream fileStream;
    
    public FileHandler(string path)
    {
        fileStream = new FileStream(path, FileMode.Open);
    }
    
    // Finalizer using expression-bodied member
    ~FileHandler() => fileStream.Dispose();
}

class Program
{
    static void Main()
    {
        FileHandler handler = new FileHandler("example.txt");
        // When handler is garbage collected, the finalizer disposes the FileStream
    }
}

Expression-Bodied Operators

public class Point
{
    public int X { get; }
    public int Y { get; }
    
    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
    
    // Overloading the '+' operator using expression-bodied member
    public static Point operator +(Point a, Point b) => new Point(a.X + b.X, a.Y + b.Y);
}

class Program
{
    static void Main()
    {
        Point p1 = new Point(2, 3);
        Point p2 = new Point(4, 5);
        Point p3 = p1 + p2;
        Console.WriteLine($"Point 3: ({p3.X}, {p3.Y})"); // Output: Point 3: (6, 8)
    }
}

4. Advantages

Conciseness

Improved Readability

Reduced Boilerplate

5. Limitations

Complexity of Expressions

// Complex method logic
public void ProcessData()
{
  Initialize();
  Validate();
  Execute();
  Cleanup();
}

Debugging Challenges

Compatibility with Older C# Versions

6. Best Practices

When to Use Expression-Bodied Members

Keeping Expressions Simple

public double CalculateArea() => Width * Height;

public void Initialize() => InitializeStep1(); InitializeStep2(); // Not valid

Consistent Coding Style

Use in LINQ and Fluent APIs

7. Common Mistakes

Overcomplicating Expressions

public int Compute(int a, int b) => (a > b ? a - b : b - a) + SomeOtherMethod(a);

public int Compute(int a, int b)
{
  int difference = a > b ? a - b : b - a;
  return difference + SomeOtherMethod(a);
}

Ignoring Readability

public string GetStatus() => isActive ? "Active" : "Inactive";

Misusing in Complex Scenarios

public void Setup() => Initialize(); Configure(); Start(); // Invalid

Forgetting to Use `=>` Correctly

public void Display() => Console.WriteLine("Hello"); // Correct
public int Add(int a, int b) => a + b; // Correct
public int Add(int a, int b) => { return a + b; } // Incorrect

8. Advanced Topics

Combining with Other C# Features

public (int Sum, int Product) Calculate(int a, int b) => (a + b, a * b);

public string Describe(object obj) => obj switch
{
  int i => $"Integer: {i}",
  string s => $"String: {s}",
  _ => "Unknown type"
};

Expression-Bodied Members in Interfaces

public interface ILogger
{
  void Log(string message);
  
  // Default implementation using expression-bodied member
  void LogInfo(string message) => Log($"INFO: {message}");
}
  
public class ConsoleLogger : ILogger
{
  public void Log(string message) => Console.WriteLine(message);
}

class Program
{
  static void Main()
  {
      ILogger logger = new ConsoleLogger();
      logger.LogInfo("Application started."); // Output: INFO: Application started.
  }
}

Lambda Expressions vs. Expression-Bodied Members

Func<int, int, int> add = (a, b) => a + b;

public int Add(int a, int b) => a + b;

9. Real-World Example

Requirements

Implementation

using System;

public class BankAccount
{
    public string AccountNumber { get; }
    public decimal Balance { get; private set; }

    // Constructor using expression-bodied member
    public BankAccount(string accountNumber, decimal initialBalance) => 
        (AccountNumber, Balance) = (accountNumber, initialBalance);

    // Deposit method using expression-bodied member
    public void Deposit(decimal amount) => Balance += amount;

    // Withdraw method using expression-bodied member with validation
    public void Withdraw(decimal amount) => 
        Balance = amount > Balance 
            ? throw new InvalidOperationException("Insufficient funds.") 
            : Balance - amount;

    // Override ToString using expression-bodied member
    public override string ToString() => 
        $"Account Number: {AccountNumber}, Balance: {Balance:C}";
}

class Program
{
    static void Main()
    {
        BankAccount account = new BankAccount("ACC12345", 1000m);
        Console.WriteLine(account); // Output: Account Number: ACC12345, Balance: $1,000.00

        account.Deposit(500m);
        Console.WriteLine(account); // Output: Account Number: ACC12345, Balance: $1,500.00

        account.Withdraw(200m);
        Console.WriteLine(account); // Output: Account Number: ACC12345, Balance: $1,300.00

        try
        {
            account.Withdraw(2000m); // Throws InvalidOperationException
        }
        catch(Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}"); // Output: Error: Insufficient funds.
        }
    }
}

Sample Output:
Account Number: ACC12345, Balance: $1,000.00
Account Number: ACC12345, Balance: $1,500.00
Account Number: ACC12345, Balance: $1,300.00
Error: Insufficient funds.

Explanation

10. Summary