C# facilitates direct memory manipulation through the use of pointers within an unsafe context. By marking a block of code with the unsafe keyword, developers can bypass standard type safety checks, enabling the declaration and use of pointer types. This capability is essential for performance-critical scenarios where the overhead of managed code—such as array bounds checking—is unacceptable.

The basic syntax involves declaring a pointer using the asterisk (*) and retrieving a variable's address using the ampersand (&). Dereferencing a pointer to access or modify the value at the memory address is also performed using the asterisk operator.

unsafe
{
    int originalValue = 100;
    int* pointer = &originalValue; 

    // Dereference to modify the value
    *pointer = 200; 

    Console.WriteLine(originalValue); // Output: 200
}

When working with managed objects like arrays or strings, the memory location might shift during garbage collection. The fixed statement pins an object in memory, preventing the garbage collector from moving it while a pointer to it is in use. This is crucial for iterating through large data structures efficiently.

int[] dataBuffer = new int[10000];

unsafe
{
    fixed (int* bufferPtr = dataBuffer)
    {
        int* current = bufferPtr;
        for (int i = 0; i < dataBuffer.Length; i++)
        {
            *current = i * 2; // Direct memory write
            current++;
        }
    }
}

Pointers are also highly effective when interacting with structures. Using the arrow (->) operator, one can directly access member fields of a struct instance via a pointer, which eliminates the overhead of copying the structure.

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

unsafe
{
    Coordinate point;
    Coordinate* ptr = &point;
    ptr->X = 10;
    ptr->Y = 20;
}

This approach is widely employed in high-performance computing, image processing libraries, and interop scenarios requiring calls to native APIs. By removing the safety net of managed memory, developers gain control but must manually manage memory boundaries to prevent access violations or memory corruption.