CLR & Runtime

byte[] buffer = new byte[1000];
Span<byte> span = buffer;
Span<byte> slice = span.Slice(10, 50);  // zero-allocation view, no copy

// Compare to traditional approach:
byte[] copy = buffer.Skip(10).Take(50).ToArray();  // allocates a new array

Common follow-ups: Why can't Span<T> be stored as a field in a class or used across await boundaries?;What's the difference between Span<T> and Memory<T> in terms of these restrictions?

<PropertyGroup>
  <ServerGarbageCollection>true</ServerGarbageCollection>   <!-- default for ASP.NET Core -->
  <ConcurrentGarbageCollection>true</ConcurrentGarbageCollection>
</PropertyGroup>

Common follow-ups: How does memory usage differ between Server and Workstation GC on the same workload?;When would a server application actually want Workstation GC instead?

<PropertyGroup>
  <TieredPGO>true</TieredPGO>  <!-- default: true in .NET 8+ -->
</PropertyGroup>

// The JIT observes, e.g., that a virtual call site almost always resolves
// to the same concrete type, and generates optimized code assuming that case

Common follow-ups: What's the overhead of the instrumentation phase before Tier 1 recompilation?;How does this interact with Native AOT, which has no runtime profiling phase?

using System.Reflection;

var assembly = Assembly.GetExecutingAssembly();
var name = assembly.GetName();
Console.WriteLine($"{name.Name} v{name.Version}");
foreach (var refAssembly in assembly.GetReferencedAssemblies())
    Console.WriteLine(refAssembly.FullName);

Common follow-ups: How does the CLR resolve which version of a referenced assembly to actually load?;What's the difference between the assembly name and its strong name?

// .NET Framework (legacy): AppDomain-based isolation
AppDomain domain = AppDomain.CreateDomain("PluginDomain");
// .NET Framework only -- not available in modern .NET

// Modern .NET equivalent: AssemblyLoadContext
var alc = new AssemblyLoadContext("PluginContext", isCollectible: true);

Common follow-ups: What cross-domain communication overhead did AppDomains impose?;Why is process isolation now preferred for strong security boundaries instead?

// Any .NET language compiles to the same intermediate representation
public class Program {
    public static void Main() {
        Console.WriteLine("Hello, .NET");
    }
}
// dotnet build -> produces IL (Intermediate Language) in a .dll
// dotnet run -> the CLR JIT-compiles that IL to native code and executes it

Common follow-ups: What specifically does the CLR handle beyond just running the code?;How is this different from how a language like C++ compiles and runs?

class Program {
    static void Main() {
        var list = new List<int> { 1, 2, 3 };
        // The CLR is responsible for: JIT-compiling this method, allocating 'list' on the
        // managed heap, verifying type safety of the List<int> operations, and eventually
        // reclaiming that memory via the garbage collector once 'list' is no longer reachable
    }
}

Common follow-ups: What specific responsibilities does the CLR hand off to the garbage collector versus the JIT compiler?;How does the CLR enforce type safety at runtime, not just compile time?

// You can inspect a compiled assembly's CIL using a tool like ildasm or dotnet-ildasm
// A simple method like this:
public int Add(int a, int b) => a + b;

// compiles to CIL roughly resembling:
// ldarg.1
// ldarg.2
// add
// ret

Common follow-ups: Why can't CIL be executed directly by a CPU without the JIT step?;How does CIL enable tools like decompilers to reconstruct readable source from a compiled DLL?

using System.Runtime.InteropServices;

public static class NativeMethods {
    [DllImport("user32.dll")]
    public static extern int MessageBox(IntPtr hWnd, string text, string caption, uint type);
}

// Calling into unmanaged Windows API code from managed C#
NativeMethods.MessageBox(IntPtr.Zero, "Hello from native code", "P/Invoke", 0);

Common follow-ups: What specific risks does calling unmanaged code introduce that managed code doesn't have?;How does the CLR's security model change once execution crosses into unmanaged territory?