C# Advanced Language Features

C# offers a plethora of advanced language features that take code efficiency to a new level. Two such features are deconstructors and tuples.

Transition: Let’s delve into the world of deconstructors and tuples in C#.

Example: Deconstructors

public class Point
{
public int X { get; }
public int Y { get; }

public Point(int x, int y)
{
X = x;
Y = y;
}

public void Deconstruct(out int x, out int y)
{
x = X;
y = Y;
}
}
In the above example, the Deconstruct method enables us to extract the X and Y coordinates from a Point object using tuple-like syntax.

Example: Tuples

public (int, int) GetCoordinates()
{
int x = 10;
int y = 20;
return (x, y);
}

// Usage
(int x, int y) = GetCoordinates();
In this example, we use tuples to return multiple values from a method and destructure them when calling the method.

C# 7.0 introduced pattern matching, a powerful feature that simplifies conditional logic and type checking.

Example: Pattern Matching with Switch

object item = “Hello, C# Pattern Matching!”;
switch (item)
{
case string s:
Console.WriteLine($”The item is a string: {s}”);
break;
case int i when i > 10:
Console.WriteLine($”The item is an integer greater than 10: {i}”);
break;
default:
Console.WriteLine(“The item does not match any known pattern.”);
break;
}
In the above example, we use pattern matching with a switch statement to check the type of the item variable and execute the corresponding code block based on the pattern match.

C# 7.0 introduced local functions, which allow us to define functions inside another method. Additionally, ref locals enable us to create references to variables.

Example: Local Functions

public int Multiply(int a, int b)
{
return MultiplyNumbers();

int MultiplyNumbers()
{
return a * b;
}
}
In this example, we define a local function MultiplyNumbers inside the Multiply method, providing better encapsulation and code organization.

Example: Ref Locals

public void Swap(ref int a, ref int b)
{
int temp = a;
a = b;
b = temp;
}
In this example, we use ref locals to swap the values of two variables directly, avoiding the need for temporary variables.