Pointer Member Access

The -> operator, known as the pointer member access operator, dereferences a pointer and accesses a member of the underlying unmanaged type in a single operation. It acts as syntactic sugar where the expression x->y is strictly evaluated as (*x).y.

Because it manipulates raw memory addresses, the -> operator can only be used within an unsafe context and requires the assembly to be compiled with the AllowUnsafeBlocks flag.

Syntax and Equivalence

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

public class PointerExample
{
    public void Run()
    {
        unsafe
        {
            Point p = new Point();
            Point* pPtr = &p;

            // Using the -> operator
            pPtr->X = 10;

            // Strictly equivalent to dereferencing followed by member access
            (*pPtr).X = 10;
        }
    }
}

Technical Constraints and Mechanics

• Operand Requirements: The left-hand operand must be a pointer to an unmanaged struct type. The right-hand operand must be an accessible member (field, property, or method) defined on that struct.
• Type Restrictions: The operator cannot be applied to pointers of type void*. The pointer must be strongly typed so the compiler can resolve the exact memory offset of the specified member.
• Managed Memory Isolation: The -> operator cannot be used with reference types (classes) or structs that contain reference types. The C# garbage collector does not track raw pointers. Consequently, the operator does not interact with object headers, method tables, or managed references.
• Memory Resolution: At compile time, -> calculates the byte offset of the target member relative to the base address of the struct. At runtime, it directly accesses that computed memory location, bypassing standard Common Language Runtime (CLR) bounds checking and type safety validation.

Master C# with Deep Grasping Methodology!

Learn More