All 19 CLR & Runtime questions
More in CLR & Runtime
What is JIT (Just-In-Time) compilation, and how does it differ from ahead-of-time (AOT) compilation? How does the CLR's type system distinguish between value types and reference types, and where is each typically allocated? What is the Common Type System (CTS), and how does it enable interoperability between different .NET languages? What is the relationship between the CLR and the .NET class library (BCL - Base Class Library)? What is the difference between the CLR's Server GC and Workstation GC modes, and how do you choose between them? What is the AppDomain concept in .NET Framework, and why was it removed from modern .NET? What is tiered compilation, and how does it balance fast startup with peak execution performance? What is boxing and unboxing, and what performance cost does it incur? How does the CLR handle exceptions at a low level, and what is the performance implication of throwing exceptions frequently? How does the CLR ensure type safety and memory safety, and what categories of bugs does this prevent compared to unmanaged languages like C++?
Advertisement
.NET › CLR & Runtime

What does the `unsafe` keyword and pointer usage in C# allow, and why would a developer opt into it?

Intermediate

Answer

The `unsafe` keyword enables code blocks that use raw pointers, pointer arithmetic, and direct memory manipulation, bypassing the CLR's normal type-safety and bounds-checking guarantees -- used sparingly for performance-critical scenarios (like high-performance buffer manipulation, interop with native libraries, or certain SIMD operations) where the overhead of managed safety checks is measurably significant and the developer accepts the increased risk of memory-safety bugs in exchange for raw performance.
unsafe {
    fixed (byte* ptr = buffer) {
        for (int i = 0; i < buffer.Length; i++) {
            *(ptr + i) = 0;  // direct pointer manipulation, bypasses bounds checking
        }
    }
}
// Requires <AllowUnsafeBlocks>true</AllowUnsafeBlocks> in the .csproj
Real-world example A high-performance image processing library uses unsafe pointer manipulation to iterate over pixel buffers directly, avoiding the bounds-checking overhead of normal array indexing in a hot loop processing millions of pixels per second.

Common follow-ups: How does Span<T> provide similar performance benefits without needing unsafe code?;What are the risks of unsafe code re-introducing memory corruption bugs?

Memory Management & Garbage Collection;Diagnostics & Performance
All 19 CLR & Runtime questions