Modern C# Features (Global Usings, File-Scoped Namespaces, Top-Level Statements)

// Program.cs -- entire program, no boilerplate needed
Console.WriteLine("Hello, World!");
var numbers = new[] { 1, 2, 3 };
Console.WriteLine(numbers.Sum());

Common follow-ups: Can you still access command-line arguments (the 'args' array) in a file using top-level statements?

// Modern: file-scoped namespace, less indentation
namespace MyApp.Services;

public class OrderService { }

// Old: block-scoped namespace, extra indentation level
namespace MyApp.Services {
  public class OrderService { }
}

Common follow-ups: Can a single file have MULTIPLE file-scoped namespace declarations?

// GlobalUsings.cs
global using System;
global using System.Linq;
global using System.Collections.Generic;

// Any other file in the project can now use List<T>, LINQ, etc. WITHOUT its own 'using' statements

Common follow-ups: Does the SDK automatically generate any implicit global usings for common namespaces, even without an explicit GlobalUsings.cs file?

<!-- .csproj -->
<PropertyGroup>
  <ImplicitUsings>enable</ImplicitUsings>
</PropertyGroup>
<!-- Now System, System.Linq, System.Collections.Generic, etc. are available everywhere automatically -->

Common follow-ups: How would you find the EXACT list of namespaces implicitly included for a specific project SDK type (like Microsoft.NET.Sdk.Web)?

public class User {
  public required string Email { get; set; }
  public string? Name { get; set; }
}
var user = new User { Email = "sam@x.com" }; // OK, Email is set
// var bad = new User(); // Error: required member 'Email' must be set

Common follow-ups: How does 'required' interact with a class's constructor, if the class also has one?

int[] array = [1, 2, 3];
List<int> list = [1, 2, 3];
Span<int> span = [1, 2, 3];

int[] combined = [..array, 4, 5, ..list]; // spread operator ('..') combines collections too

Common follow-ups: How does the spread operator ('..') inside a collection expression work to combine multiple existing collections?

// Modern: primary constructor eliminates DI boilerplate
public class OrdersController(IOrderService orderService, ILogger<OrdersController> logger) : ControllerBase {
  [HttpGet]
  public IActionResult Get() {
    logger.LogInformation("Fetching orders");
    return Ok(orderService.GetAll());
  }
}
// No separate private fields or explicit constructor body needed

Common follow-ups: What's a real trade-off or gotcha of using primary constructor parameters directly, instead of assigning them to explicit readonly fields?

// GeneratedFile1.g.cs
file class Helpers { public static string Format(string s) => s.Trim(); } // invisible outside this file

// GeneratedFile2.g.cs
file class Helpers { public static int Format(int n) => n; } // a DIFFERENT, non-conflicting 'Helpers' type

Common follow-ups: Would a regular 'private' or 'internal' modifier have been sufficient to solve this same naming-collision problem?

var greet = (string name, string greeting = "Hello") => $"{greeting}, {name}!";
Console.WriteLine(greet("Sam")); // "Hello, Sam!" -- uses the default
Console.WriteLine(greet("Sam", "Hi")); // "Hi, Sam!"

Common follow-ups: Does this default-parameter lambda syntax work when the lambda is assigned to a built-in Func<> or Action<> delegate type?

string json = """
{
  "name": "Sam",
  "path": "C:\\Users\\Sam"
}
"""; // no escaping needed for quotes or backslashes at all

string interpolated = $"""
Hello, {name}! Your path is "C:\literal\path".
""";

Common follow-ups: How does interpolation inside a raw string literal avoid ambiguity with literal '{' and '}' characters that might appear in embedded JSON?