C# 8 Features

Example (Simple Idea)

Imagine you are reading rows from a database and you want to process them one-by-one without loading everything in memory. C# 8.0 gives you asynchronous streams to do this safely and efficiently.

// C# 8.0 concept preview (we'll learn this in detail later)
public async IAsyncEnumerable<int> GetNumbersAsync()
{
    for (int i = 1; i <= 3; i++)
    {
        await Task.Delay(200);
        yield return i;
    }
}

Example (Before vs After: Slicing)

Indices and ranges make substring/array slicing more readable.

// Before (older style)
int[] a = { 10, 20, 30, 40, 50 };
int[] middle = a.Skip(1).Take(3).ToArray();

// After (C# 8.0 ranges)
int[] b = { 10, 20, 30, 40, 50 };
int[] mid = b[1..4]; // 20,30,40

Example (.csproj settings)

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>netcoreapp3.1</TargetFramework>
    <LangVersion>8.0</LangVersion>
    <Nullable>enable</Nullable>
  </PropertyGroup>
</Project>

Example (readonly member)

public struct Money
{
    public decimal Amount { get; }
    public Money(decimal amount) => Amount = amount;

    // C# 8.0: readonly member
    public readonly string Format() => $@"₹ {Amount:0.00}";
}

// Usage
var m = new Money(199.5m);
Console.WriteLine(m.Format());

Example (default implementation)

public interface ILogger
{
    void Log(string message);

    // C# 8.0: default interface method
    void LogInfo(string message) => Log("INFO: " + message);
}

public class ConsoleLogger : ILogger
{
    public void Log(string message) => Console.WriteLine(message);
}

// Usage
ILogger logger = new ConsoleLogger();
logger.LogInfo("Server started");

Example (switch expression + property pattern)

public record Order(decimal Total, bool IsPremium);

public static string GetDiscountLabel(Order o) => o switch
{
    { IsPremium: true, Total: >= 5000 } => "Premium 20% Discount",
    { IsPremium: true }               => "Premium 10% Discount",
    { Total: >= 3000 }                => "Regular 5% Discount",
    _                                 => "No Discount"
};

// Usage
Console.WriteLine(GetDiscountLabel(new Order(6000, true)));

Example (using var)

using var writer = new StreamWriter("log.txt");
writer.WriteLine("App started");
writer.WriteLine("App finished");
// Dispose happens automatically here (end of scope)

Example (static local function)

public static bool IsValidEmail(string email)
{
    // static local function: cannot capture outer variables
    static bool HasAtSymbol(string value) => value.Contains("@");

    if (string.IsNullOrWhiteSpace(email)) return false;
    return HasAtSymbol(email);
}

Example (conceptual pattern)

// Example pattern: a ref struct with Dispose method
public ref struct TempBuffer
{
    public void Dispose()
    {
        // cleanup logic (concept)
    }
}

public static void UseBuffer()
{
    // C# 8.0: using works with ref struct (pattern-based)
    using var buf = new TempBuffer();
    // work with buf
}

Example (safe handling)

#nullable enable

public static string GetDisplayName(string? name)
{
    if (name is null) return "Guest";
    return name.Trim();
}

// Usage
Console.WriteLine(GetDisplayName(null));      // Guest
Console.WriteLine(GetDisplayName("  Gopi ")); // Gopi

Example (lazy init)

List<string>? logs = null;

// Later...
logs ??= new List<string>();
logs.Add("Started");

Example (producer + consumer)

public static async IAsyncEnumerable<string> ReadLinesAsync()
{
    // Simulating "lines coming over time"
    yield return "Line 1";
    await Task.Delay(150);
    yield return "Line 2";
    await Task.Delay(150);
    yield return "Line 3";
}

public static async Task Demo()
{
    await foreach (var line in ReadLinesAsync())
    {
        Console.WriteLine(line);
    }
}

Example (custom async disposable)

public class AsyncConnection : IAsyncDisposable
{
    public async ValueTask DisposeAsync()
    {
        await Task.Delay(100); // simulate async cleanup
        Console.WriteLine("Async cleanup done");
    }
}

public static async Task Demo()
{
    await using var conn = new AsyncConnection();
    Console.WriteLine("Using connection...");
}

Example (slice + last item)

int[] a = { 10, 20, 30, 40, 50 };

int last = a[^1];     // 50
int[] slice = a[1..4];// 20,30,40

Console.WriteLine(last);
Console.WriteLine(string.Join(",", slice));

Example (generic constraint)

public struct Point2D
{
    public int X;
    public int Y;
}

public static int SizeOf<T>() where T : unmanaged
{
    // concept: safe to do low-level operations
    return sizeof(T);
}

Console.WriteLine(SizeOf<Point2D>());

Example (temporary buffer)

// Advanced concept: stackalloc buffer (simplified example)
Span<int> buf = stackalloc int[3];
buf[0] = 10;
buf[1] = 20;
buf[2] = 30;

Console.WriteLine(buf[1]);

Example (path template)

string user = "Gopi";
	string folder = $@"C:\Users\{user}\Documents\Reports";
	Console.WriteLine(folder);

Checklist Table

Starter Skeleton (C#)

#nullable enable
public static class LogProcessor
{
    public static async Task RunAsync(string? inputPath)
    {
        if (string.IsNullOrWhiteSpace(inputPath))
        {
            Console.WriteLine("Input path is required.");
            return;
        }

        using var writer = new StreamWriter("summary.txt");
        await foreach (var line in ReadLogLinesAsync(inputPath))
        {
            // classify with pattern matching (exercise)
            await writer.WriteLineAsync(line);
        }
    }

    public static async IAsyncEnumerable<string> ReadLogLinesAsync(string path)
    {
        using var reader = new StreamReader(path);
        while (!reader.EndOfStream)
        {
            var line = await reader.ReadLineAsync();
            if (line != null) yield return line;
        }
    }
}

Questions

1. Nullable reference types mainly provide:
   • A) Runtime exceptions for null
   • B) Compile-time warnings for risky null usage
   • C) Automatic null conversion at runtime
   • D) Removal of null from C#
2. Which syntax is used to dispose asynchronously?
   • A) using var
   • B) await using
   • C) dispose using
   • D) async using()
3. What does a[^1] return?
   • A) First item
   • B) Second item
   • C) Last item
   • D) Middle item
4. Using declarations dispose resources:
   • A) Immediately after creation
   • B) At end of current scope
   • C) Only when GC runs
   • D) Only if you call Dispose manually
5. Static local functions:
   • A) Can capture outer variables freely
   • B) Cannot capture outer variables
   • C) Always run faster than normal methods
   • D) Are only for async methods
6. IAsyncEnumerable<T> is commonly consumed using:
   • A) foreach
   • B) await foreach
   • C) for loop only
   • D) while(true)
7. Default interface methods are especially useful for:
   • A) Reducing class file size
   • B) Evolving interfaces without breaking implementations
   • C) Replacing inheritance
   • D) Removing interfaces

Answer Key

• 1) B
• 2) B
• 3) C
• 4) B
• 5) B
• 6) B
• 7) B

Placeholder Blocks

• ZIP: CSharp8_Samples.zip (source code, exercises)
• PPT: CSharp8_Features_Slides.pptx (training deck)
• DOC: CSharp8_Notes.docx (printable notes)

Easy (1–5)

1. Nullable Display Name
   Problem: Write a method that returns "Guest" when the input name is null/empty; otherwise returns trimmed name.
   I/O: Input: string? name → Output: string
   Example: Input: null → Output: Guest
   Constraints: name length ≤ 200
   Hint: Use nullable reference types and a null check.
2. Lazy Initialize List
   Problem: If a List<string>? is null, initialize it and add a message.
   I/O: Input: List<string>? logs, string msg → Output: List<string>
   Example: Input: null,"Hi" → Output: ["Hi"]
   Constraints: msg length ≤ 100
   Hint: Use ??= to initialize.
3. Last Element Finder
   Problem: Return the last element of an int array using indices (^).
   I/O: Input: int[] a → Output: int
   Example: [5,7,9] → 9
   Constraints: array length ≥ 1
   Hint: Use a[^1].
4. Middle Slice
   Problem: Return a slice of an array from index 1 to index 3 (end exclusive).
   I/O: Input: int[] a → Output: int[]
   Example: [10,20,30,40,50] → [20,30,40]
   Constraints: length ≥ 4
   Hint: Use ranges: a[1..4].
5. Using Declaration File Write
   Problem: Write two lines to a file using using declaration (no using block).
   I/O: Input: string path → Output: file created/updated
   Example: path="out.txt" → file contains 2 lines
   Constraints: valid path
   Hint: using var writer = new StreamWriter(path);

Medium (6–10)

6. Order Discount Rule Engine
   Problem: Use switch expression + property patterns to return discount labels based on Total and IsPremium.
   I/O: Input: (decimal Total, bool IsPremium) → Output: string
   Example: (6000,true) → "Premium 20% Discount"
   Constraints: Total ≥ 0
   Hint: Use record + switch expression with property patterns.
7. Static Local Validator
   Problem: Write a method that validates a product code using a static local function (no captures).
   I/O: Input: string code → Output: bool
   Example: "PRD-1001" → true
   Constraints: code length ≤ 50
   Hint: Put regex/format checks into static local function.
8. Async Stream Number Generator
   Problem: Create an async iterator that yields numbers 1..N with delay, then consume using await foreach.
   I/O: Input: int N → Output: prints numbers
   Example: N=3 → prints 1,2,3
   Constraints: 1 ≤ N ≤ 1000
   Hint: async IAsyncEnumerable + yield return + Task.Delay.
9. Null-safe Customer Mapper
   Problem: Map a DTO to a domain model ensuring nullable fields are handled safely (no warnings).
   I/O: Input: CustomerDto → Output: Customer
   Example: dto.Name=null → model.Name="Unknown"
   Constraints: keep model non-nullable
   Hint: Use ?? and null checks; avoid overusing !.
10. Path Template Builder
    Problem: Build a multi-line report header using interpolated verbatim string $@"...".
    I/O: Input: string user, DateTime date → Output: string header
    Example: user=Gopi → includes user line
    Constraints: header ≤ 2000 chars
    Hint: Use $@"Line1{var}\nLine2".

Hard (11–15)

11. Async Log Processor with Filtering
    Problem: Read a huge log file using async streams, filter only ERROR lines, write them to a new file using using declarations.
    I/O: Input: inputPath, outputPath → Output: filtered file
    Example: "app.log" → "errors.log" contains only ERROR lines
    Constraints: file can be very large
    Hint: async iterator yields lines; consumer writes only matching lines.
12. Async Disposable Wrapper
    Problem: Create a custom resource that buffers data and flushes asynchronously on DisposeAsync; use await using in a demo.
    I/O: Input: list of messages → Output: flush confirmation
    Example: ["a","b"] → prints "Flushed 2 items"
    Constraints: must not block thread in cleanup
    Hint: Implement IAsyncDisposable with ValueTask DisposeAsync().
13. Nullable-Aware API Response Builder
    Problem: Build an API response object where optional fields are nullable, but required fields are non-nullable. Ensure zero nullable warnings.
    I/O: Input: domain model with optional values → Output: response DTO
    Example: optional description null → response.Description=null
    Constraints: no suppression operator (!) allowed except rare cases
    Hint: Design DTO with string? only where needed; validate required fields.
14. Rule Engine with Pattern Matching + Ranges
    Problem: Given an array of daily sales, classify it: - If last 3 days are all >= 1000 → "Hot" - If last day < 200 → "Cold" - else "Normal"
    I/O: Input: int[] sales → Output: string
    Example: [500,1200,1300,1500] → Hot
    Constraints: length ≥ 3
    Hint: Use sales[^3..] to slice last 3, then pattern/conditions.
15. High-performance Parser (Stackalloc + Span)
    Problem: Parse a 3-digit code from a string without allocations using Span and a small stackalloc buffer (conceptual).
    I/O: Input: string s like "ID:123" → Output: int 123
    Example: "ID:123" → 123
    Constraints: input format guaranteed; keep allocations minimal
    Hint: Use Span and stackalloc for temp; convert digits manually.