C# Features

C# 12 focuses on practical improvements that help you write more expressive code with less boilerplate. Many of these features pair naturally with modern .NET projects and improve readability without sacrificing performance. You’ll see enhancements around constructors, collections, memory-friendly data structures, and safer “opt-in” APIs. If you already know C# basics, C# 12 makes your day-to-day code feel smoother and more maintainable.

To use C# 12 reliably, start with a modern .NET project and confirm the selected language version. In most cases, using the latest .NET SDK automatically enables the latest C# version. If you need explicit control (common in enterprises), you can set language version in your project file. Keep your team consistent across local builds and CI pipelines.

<!-- MyApp.csproj -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <LangVersion>12.0</LangVersion>
    <Nullable>enable</Nullable>
  </PropertyGroup>
</Project>

Real-world use case: Large teams pin LangVersion to avoid unexpected compile errors when some developers update SDK earlier than others.

Primary constructors allow you to declare constructor parameters directly on the class or struct declaration. This is especially useful when your type mainly exists to store and validate incoming values. The parameters are in scope for field/property initialization, helping you avoid repeating assignments. Think of it as a cleaner “front door” for creating objects, while keeping the type’s purpose obvious.

public class Customer(int id, string name)
{
    public int Id { get; } = id > 0 ? id : throw new ArgumentOutOfRangeException(nameof(id));
    public string Name { get; } = !string.IsNullOrWhiteSpace(name) ? name : throw new ArgumentException("Name required");

    public override string ToString() => $"{Id} - {Name}";
}

// Usage:
var c = new Customer(101, "Asha");
Console.WriteLine(c);

Real-world use case: DTO-style domain objects in microservices where you want quick validation at construction time.

Collection expressions introduce a compact way to create and combine collections. They reduce noise when you build lists/arrays and when you “spread” existing items into a new collection. This is great for APIs that accept sequences, especially where you used to write multiple lines of setup. The result: fewer braces, fewer temp variables, and code that reads like the data it represents.

int[] defaults = { 1, 2 };
int[] userItems = { 7, 8 };

// Conceptually: [..defaults, 5, ..userItems]
var merged = new List<int>();
merged.AddRange(defaults);
merged.Add(5);
merged.AddRange(userItems);

Console.WriteLine(string.Join(", ", merged));

In real C# 12 projects, the syntax can be much more concise (depending on the target type). The key learning: the language is moving toward a consistent “collection literal” feel.

Real-world use case: Building API query filters: default filters + user-selected filters merged cleanly.

Inline arrays help you store a small, fixed number of elements directly inside a struct without separate heap allocations. This can improve performance by keeping data contiguous and avoiding extra objects. They are especially useful in low-level libraries, parsers, or numeric scenarios where the size is known. If you’re building everyday business apps, you may use them less often—but it’s powerful to understand them.

public struct SensorSnapshot
{
    // Simple fixed layout (illustrative):
    public float R0;
    public float R1;
    public float R2;
    public float R3;

    public float Average() => (R0 + R1 + R2 + R3) / 4f;
}

// Usage:
var s = new SensorSnapshot { R0 = 26.2f, R1 = 26.1f, R2 = 26.4f, R3 = 26.0f };
Console.WriteLine(s.Average());

Real-world use case: Streaming telemetry: keep a tiny rolling window of values without allocating many arrays.

Lambdas are compact functions often used for filters, transformations, and event handlers. Optional parameters in lambdas (where supported) can reduce the need for multiple overloads or wrapper functions. This can be helpful when you build reusable libraries that accept delegates with “extra” context. The main value: simpler calling code while keeping the callback flexible.

public static void Process(IEnumerable<int> numbers, Func<int, string, string> formatter)
{
    foreach (var n in numbers)
        Console.WriteLine(formatter(n, "default-tag"));
}

// Usage:
Process(new[] { 1, 2, 3 }, (n, tag) => $"{tag}: {n*n}");

Real-world use case: Logging pipelines where callbacks optionally include correlation IDs or categories.

When you pass a large struct, the runtime may copy it, which can be expensive in tight loops. Using by reference avoids copying, but plain ref allows mutation. ref readonly is a safer middle ground: it prevents modifications but still avoids copies. This is a strong feature for performance-sensitive libraries and numeric code.

public readonly struct Point3D
{
    public double X { get; init; }
    public double Y { get; init; }
    public double Z { get; init; }
}

public static double DistanceFromOrigin(ref readonly Point3D p)
{
    return Math.Sqrt(p.X * p.X + p.Y * p.Y + p.Z * p.Z);
}

// Usage:
var p = new Point3D { X = 10, Y = 20, Z = 5 };
Console.WriteLine(DistanceFromOrigin(ref p));

Real-world use case: Game engines and simulation systems that handle many vectors/points per frame.

Type aliases help when your code uses complex generic types or tuples repeatedly. Instead of repeating long type signatures everywhere, you define a single alias name. In C# 12, aliasing becomes more flexible, helping modern codebases stay readable. This improves maintainability and reduces mistakes when copy-pasting type shapes.

// Alias example (illustrative)
using CustomerRow = System.ValueTuple<int, string>;

public static CustomerRow CreateCustomerRow(int id, string name)
{
    return (id, name);
}

var row = CreateCustomerRow(1, "Ravi");
Console.WriteLine(row);

Real-world use case: Data processing layers where types are “pipeline shapes” (e.g., tuple rows, nested generics).

When you ship libraries, sometimes you want early feedback before finalizing an API. The experimental attribute helps you “label” methods/types as preview, so developers get warnings. This improves communication: consumers know the risk and can avoid depending on unstable behavior. It also supports better versioning strategies for teams shipping internal frameworks.

[Obsolete("Experimental API: may change", false)]
public static class PreviewFeatures
{
    public static string NewFormatter(string input)
        => input.Trim().ToUpperInvariant();
}

// Usage:
Console.WriteLine(PreviewFeatures.NewFormatter("  hello  "));

Real-world use case: Internal platform teams releasing preview helpers to multiple product teams before formal support.

The best way to adopt C# 12 is incrementally: enable the SDK, then modernize one feature at a time. Focus on readability first, and measure performance only when you have evidence (profiling). Prefer features that reduce boilerplate without obscuring intent (primary constructors, aliases). Always keep code reviews and tests strong—language upgrades should never reduce correctness.

In this mini project, you’ll model students and registrations using cleaner construction, readable type aliases, and performance-friendly value types where it matters. The goal is to practice feature selection: not every feature fits every file. You’ll also learn to keep API surfaces safe by marking preview methods clearly.

using StudentRow = System.ValueTuple<int, string>;

public class Student(int id, string name)
{
    public int Id { get; } = id;
    public string Name { get; } = name;
}

public static class Registry
{
    public static List<Student> Seed()
        => new()
        {
            new Student(1, "Ananya"),
            new Student(2, "Karthik"),
            new Student(3, "Meera")
        };

    public static IEnumerable<StudentRow> ExportRows(IEnumerable<Student> students)
        => students.Select(s => (s.Id, s.Name));
}

Real-world use case: Training institute portals can model students/courses with minimal boilerplate and clearer data flow.

1. Explain primary constructors. What problem do they solve compared to normal constructors?
2. When would you use inline arrays and when would you avoid them?
3. What does ref readonly guarantee and why is it useful for large structs?
4. How do type aliases improve code maintainability in generic-heavy code?
5. How would you ship a preview API safely in a shared library?
6. What strategy would you follow to upgrade a large solution to C# 12?

1. Primary constructors are mainly used to:
   A) Improve SQL performance
   B) Reduce boilerplate by declaring constructor parameters at the type declaration
   C) Replace interfaces completely
   D) Avoid using properties
2. ref readonly is best described as:
   A) Pass by value and allow mutation
   B) Pass by reference and prevent mutation
   C) Pass by pointer and allow mutation
   D) Pass by value and prevent reading
3. Inline arrays are most helpful when:
   A) You need dynamic resizing frequently
   B) You need fixed-size buffers with fewer allocations
   C) You want to store strings in database
   D) You want to avoid using structs
4. Type aliasing is helpful to:
   A) Hide exceptions from code
   B) Rename variables at runtime
   C) Give readable names to complex type signatures
   D) Disable compilation warnings
5. Marking an API as experimental is useful to:
   A) Guarantee backwards compatibility forever
   B) Communicate that the API may change or be removed
   C) Speed up garbage collection
   D) Remove the need for documentation

This section is a placeholder for your ItTechGenie assets. You can later replace the buttons with real downloads from your MVC project (controller action / static files).

Solve these practical problems to gain confidence with C# 12 concepts. Keep your solutions clean, add validations, and write short unit-style tests where possible.

Easy (5)

1. Primary Constructor Basics
   Problem: Create a Book type using a primary constructor with id and title, and print it.
   Input/Output: Input: id, title → Output: formatted string.
   Example Input: 10, "Clean Code" → Example Output: "10 - Clean Code"
   Constraints: id > 0, title not empty
   Hint: Validate in property initializers.
2. Alias a Tuple
   Problem: Create a type alias for (int Id, string Name) and return it from a function.
   Example Input: 1, "Riya" → Example Output: "(1, Riya)"
   Constraints: Name length 1..50
   Hint: Use a using alias at top of file.
3. Simple Collection Build
   Problem: Build a collection of 5 integers and print them comma-separated.
   Example Input: (none) → Example Output: "1,2,3,4,5"
   Constraints: Exactly 5 items
   Hint: Focus on clean initialization.
4. Lambda Formatter
   Problem: Pass a lambda to format each number as "Square: x".
   Example Input: [2,3] → Example Output: "Square: 4", "Square: 9"
   Constraints: Positive integers only
   Hint: Use Func<int,string>.
5. Readonly Struct Distance
   Problem: Create a small immutable struct with X,Y and compute distance from origin.
   Example Input: (3,4) → Example Output: 5
   Constraints: -1000..1000
   Hint: Use Math.Sqrt.

Medium (5)

6. Primary Constructor + Validation
   Problem: Create Employee with (id, name, salary) and reject invalid salary (<= 0).
   Example Input: 2, "Ajay", 50000 → Output: "Ajay (2) - 50000"
   Constraints: salary > 0
   Hint: Throw an exception in property initialization.
7. Merge Two Lists (Readable)
   Problem: Merge default roles ["User"] with user roles input; avoid duplicates.
   Example Input: ["Admin","User"] → Example Output: ["User","Admin"] (unique)
   Constraints: Max 20 roles
   Hint: Use HashSet for uniqueness.
8. ref readonly Performance Pattern
   Problem: Given a large struct (e.g., 10 fields), write a method that reads values without copying.
   Example Input: struct values → Output: computed sum
   Constraints: No mutation allowed
   Hint: Use ref readonly parameter.
9. Alias a Nested Generic
   Problem: Alias Dictionary<string, List<int>> as ScoreIndex and build a sample map.
   Example Input: ("Asha": [90,95]) → Output: average 92.5
   Constraints: 1..100 scores
   Hint: Create helper method to average.
10. Experimental API Wrapper
    Problem: Create a “preview” formatter method and ensure callers see a warning (simulate using attributes).
    Example Input: " hi " → Output: "HI"
    Constraints: string length 0..200
    Hint: Use Obsolete with message to simulate preview.

Hard (5)

11. Mini Registry with Clean Construction
    Problem: Build a registry that adds students, prevents duplicate IDs, and exports tuples using alias.
    Input/Output: Input: list of students → Output: exported rows (Id, Name)
    Example Input: (1,"Meera"), (1,"Meera2") → Output: second rejected
    Constraints: Up to 10,000 entries
    Hint: Use Dictionary for fast lookup.
12. Rolling Window Snapshot
    Problem: Maintain last 4 readings and compute average; no dynamic resizing allowed.
    Example Input: 10,20,30,40 → Output: 25
    Constraints: Exactly 4 stored values
    Hint: Use fixed fields or inline-buffer style struct.
13. Functional Pipeline
    Problem: Accept a list and a lambda pipeline: filter + transform + format output lines.
    Example Input: [1..10], filter even → Output: "E: 4", "E: 16"...
    Constraints: N up to 100,000
    Hint: Avoid multiple enumerations; consider single pass.
14. Safe Large Struct Calculations
    Problem: Implement vector magnitude and dot product using ref readonly to minimize copies.
    Example Input: v=(1,2,3), w=(4,5,6) → Output: dot=32
    Constraints: doubles in -1e6..1e6
    Hint: Keep structs immutable and readonly.
15. Migration Assistant (Rules)
    Problem: Write a console app that scans class files (strings) and flags opportunities: repeated constructor assignments, complex generic types, and preview APIs used.
    Example Input: source text → Output: list of suggestions
    Constraints: Up to 1MB text input
    Hint: Use simple pattern matching; focus on reporting, not perfect parsing.