c# advanced : Positional Patterns

** meta description*:
In C#, positional patterns and the **Deconstruct* method provide an expressive way to handle data from objects. These features help you write clear, readable, and concise code, especially when evaluating specific properties of an object. This guide'll explore these concepts using a practical example with a Student class.

What is the Deconstruct Method?

The Deconstruct method in C# allows an object to "deconstruct" itself, which means breaking down its properties into separate, local variables. This is useful when you want quick access to multiple values from a single object without referencing each property directly.

Imagine a Student class with two properties:

• Score (e.g., an exam grade)
• HasGoodAttendance (indicates if the student has maintained good attendance)

Here's how we can set up the Student class with a Deconstruct method:

public class Student
{
    public int Score { get; set; }
    public bool HasGoodAttendance { get; set; }

    // Deconstruct method to break down the student into individual values
    public void Deconstruct(out int score, out bool hasGoodAttendance)
    {
        score = Score;
        hasGoodAttendance = HasGoodAttendance;
    }
}

The Deconstruct method takes Score and HasGoodAttendance and makes them available as separate values. This means you can access them with code like this:

var student = new Student { Score = 90, HasGoodAttendance = true };
var (score, attendance) = student;

Console.WriteLine($"Score: {score}, Attendance: {attendance}");
// Output: Score: 90, Attendance: True

Introducing Positional Patterns

Positional patterns are a way to match on the values of an object, using its position in the deconstructed output. Let’s say you want to determine a student’s performance based on their score and attendance.

Step 1: Defining Performance Status with Positional Patterns

We want to classify a student’s performance as follows:

1. Excellent if their score is 85 or above and they have good attendance.
2. Needs Improvement if their score is 70 or above but attendance is poor.
3. Warning if their score is below 70, regardless of attendance.

With positional patterns, you can handle all these cases easily:

string GetPerformanceStatus(Student student)
{
    return student switch
    {
        (>= 85, true) => "Excellent performance with good attendance",
        (>= 70, false) => "Needs improvement due to poor attendance",
        (< 70, _) => "Warning: Low score",
        _ => "Unknown performance status"
    };
}

Explanation:

1. (>= 85, true) matches students with a score of 85 or more and good attendance.
2. (>= 70, false) matches students with a score of 70 or more but poor attendance.
3. (< 70, _) matches any student with a score below 70, where _ is a discard symbol (meaning it ignores the attendance value).
4. _ serves as a fallback to handle any unmatched cases.

Step 2: Using the Function

Now, let's create some Student objects and test the GetPerformanceStatus function:

Student student1 = new Student { Score = 90, HasGoodAttendance = true };
Student student2 = new Student { Score = 75, HasGoodAttendance = false };
Student student3 = new Student { Score = 65, HasGoodAttendance = true };

Console.WriteLine(GetPerformanceStatus(student1)); // Output: Excellent performance with good attendance
Console.WriteLine(GetPerformanceStatus(student2)); // Output: Needs improvement due to poor attendance
Console.WriteLine(GetPerformanceStatus(student3)); // Output: Warning: Low score

Key Benefits of Using Positional Patterns

1. Clarity: Positional patterns keep your code organized by handling multiple conditions in one place.
2. Simplicity: You don’t need to write multiple if statements to check each property separately.
3. Flexibility: Using _ (discard) allows you to ignore properties that aren’t relevant for certain conditions.

Summary

The Deconstruct method and Positional Patterns can make your C# code cleaner and more expressive:

• The Deconstruct method allows for breaking down object properties into individual variables.
• Positional patterns help you match specific combinations of values in an intuitive way.

With these tools, you can simplify decision-making in your code by matching on specific properties and adding conditions all in one place.

Here are assignments to practice Deconstruct and Positional Patterns with three levels of difficulty.

Assignments on Deconstruct and Positional Patterns

Level 1: Basic Deconstruction

Task: Create a Book class with the following properties:

• Title (string)
• PageCount (int)

1. Implement a Deconstruct method that breaks down the Book object into title and pageCount.
2. Create a few Book instances and deconstruct them into local variables.
3. Print the title and page count of each book.

Example:

public class Book
{
    public string Title { get; set; }
    public int PageCount { get; set; }

    public void Deconstruct(out string title, out int pageCount)
    {
        title = Title;
        pageCount = PageCount;
    }
}

Expected Output:

Title: "C# Basics", Page Count: 300
Title: "Advanced C#", Page Count: 500

Level 2: Simple Positional Pattern Matching

Task: Extend the Book class from Level 1 by adding a HasDiscount property (bool).

1. Write a function GetBookStatus that uses positional patterns to determine the book’s status based on the following rules:
   • If the book has more than 400 pages and has a discount, return "Large book with discount".
   • If the book has 400 pages or fewer and has a discount, return "Regular book with discount".
   • If the book has more than 400 pages and no discount, return "Large book without discount".
   • Otherwise, return "Regular book without discount".

Example Usage:

Book book1 = new Book { Title = "C# Basics", PageCount = 300, HasDiscount = true };
Book book2 = new Book { Title = "Advanced C#", PageCount = 500, HasDiscount = false };

Console.WriteLine(GetBookStatus(book1)); // Output: Regular book with discount
Console.WriteLine(GetBookStatus(book2)); // Output: Large book without discount

Hint: Use positional patterns with the discard _ to ignore values you don’t need to match.

Level 3: Advanced Positional Patterns with Tuples

Task: Imagine you’re building a simple inventory system for a Gadget. Each gadget has:

• Type (string, e.g., "Phone", "Tablet")
• Stock (int)
• IsInDemand (bool)

1. Create a tuple (string Type, int Stock, bool IsInDemand) that represents a gadget.
2. Write a function GetStockStatus that uses positional patterns to classify the gadget’s stock status:
   • If the gadget has more than 50 units in stock and is in demand, return "High stock and in demand".
   • If the gadget has 50 or fewer units in stock and is in demand, return "Low stock but in demand".
   • If the gadget has more than 50 units but isn’t in demand, return "High stock but not in demand".
   • For any other cases, return "Low stock and not in demand".

Example Usage:

var gadget1 = ("Phone", 60, true);
var gadget2 = ("Tablet", 30, true);
var gadget3 = ("Phone", 80, false);

Console.WriteLine(GetStockStatus(gadget1)); // Output: High stock and in demand
Console.WriteLine(GetStockStatus(gadget2)); // Output: Low stock but in demand
Console.WriteLine(GetStockStatus(gadget3)); // Output: High stock but not in demand

Hint: Use positional patterns to check the stock amount and demand status within the tuple.