🚀 What’s New in C#: Latest Features You Should Know (C# 11 & 12)

C# has always been one of the most popular programming languages in the world, thanks to its simplicity, flexibility, and strong support from Microsoft. With every new version, C# becomes more powerful, modern, and developer-friendly.

The latest releases, C# 11 and C# 12, have introduced a number of exciting features that improve code readability, performance, and productivity. In this article, we’ll dive deep into the top new features in C#, with examples, pros & cons, and real-time use cases.

---

🔹 Why New Features Matter in C#

Before jumping into the list, let’s quickly understand why these updates are important:

• Cleaner code → Less boilerplate, easier to read.

• Faster execution → Performance improvements with UTF-8 literals, inline arrays, etc.

• Stronger safety → Required members ensure you don’t forget important object initialization.

• Better productivity → Developers spend less time writing repetitive code.

Now, let’s go feature by feature.

---

1️⃣ Raw String Literals (C# 11)

Working with JSON, XML, or SQL queries in C# often required lots of escape characters (\). With raw string literals, you can write multi-line strings exactly as they are.

✅ Example:

string json = """
{
  "name": "Hasitha",
  "age": 12,
  "city": "Hyderabad"
}
""";

Console.WriteLine(json);

🔍 Real-time Use Case:

• Writing SQL queries in C# without escaping ' or \.

• Handling JSON templates for APIs.

👍 Pros:

• Cleaner and more readable.

• No escaping required.

👎 Cons:

• May look confusing if developers are not aware of """.

---

2️⃣ List Patterns (C# 11)

Pattern matching got an upgrade with list patterns, making it easier to match arrays and collections.

✅ Example:

int[] numbers = { 1, 2, 3 };

if (numbers is [1, 2, 3])
    Console.WriteLine("Perfect match!");

if (numbers is [1, ..])
    Console.WriteLine("Starts with 1");

🔍 Real-time Use Case:

• Data validation (e.g., verifying fixed-length codes).

• Matching API response arrays.

---

3️⃣ Required Members (C# 11)

You can now enforce that certain properties must be initialized when creating objects.

✅ Example:

class Student
{
    public required string Name { get; init; }
    public int Age { get; init; }
}

var s = new Student { Name = "Cherry", Age = 12 }; // ✅ Must set Name

🔍 Real-time Use Case:

• Avoiding half-initialized objects (like a User without Email).

---

4️⃣ File-Scoped Types (C# 11)

Want to create helper classes just for a single file? Now you can!

file class Helper
{
    public static void Print() => Console.WriteLine("File-scoped class");
}

✅ This prevents accidental usage of that class outside its file.

---

5️⃣ UTF-8 String Literals (C# 11)

C# now allows UTF-8 encoded strings with u8. This improves performance when working with text.

ReadOnlySpan<byte> utf8 = "Hello World"u8;

🔍 Use Case: High-performance applications like game development, IoT, and network protocols.

---

6️⃣ Primary Constructors for Classes & Structs (C# 12)

Earlier, primary constructors were available only for records. Now, classes and structs can also use them!

✅ Example:

class Employee(string name, int age)
{
    public void Display() => Console.WriteLine($"{name}, {age}");
}

var e = new Employee("Hasitha", 12);
e.Display();

🔍 Real-time Use Case:

• Quick creation of DTOs (Data Transfer Objects).

• Reduces boilerplate constructors in small classes.

---

7️⃣ Collection Expressions (C# 12)

You can now use a short-hand syntax for creating collections.

✅ Example:

int[] numbers = [1, 2, 3];
List<string> names = ["Cherry", "Hasitha"];

🔍 Use Case: Cleaner initialization of arrays, lists, and dictionaries.

---

8️⃣ Inline Arrays (C# 12)

For performance-critical code, inline arrays reduce heap allocations.

✅ Example:

using System.Runtime.CompilerServices;

[InlineArray(3)]
struct MyArray<T>
{
    private T _element0;
}

🔍 Use Case: Gaming, AI, and systems programming where memory optimization is key.

---

🎯 Summary

C# is evolving rapidly to compete with modern languages like Python, Kotlin, and Rust. The latest features in C# 11 and C# 12 bring improvements in readability, safety, and performance.

• ✅ Use raw strings for JSON & SQL.

• ✅ Use list patterns for cleaner matching.

• ✅ Use required members to enforce initialization.

• ✅ Use primary constructors & collection expressions for less boilerplate.

• ✅ Use inline arrays & UTF-8 literals for high-performance apps.

If you’re a .NET developer, upgrading to the latest version of C# will save you time, reduce bugs, and make your codebase modern. 🚀