Can unsafe code in C# cause memory corruption?

Question

Basically, memory corruption is caused by overwriting memory you're not supposed to overwrite. I am wondering if this is possible with unsafe code in C# (i.e. not by calling into external unmanaged code). I see two possible cases:

• Accessing a null pointer -> Trapped by the CLR, throws a NullReferenceException
• Accessing a pointer to an invalid random memory location -> Trapped by the CLR, throws an AccessViolationException

In both cases it seems the runtime detects and prevents the potential memory corruption from taking place. Therefore, is it possible to corrupt memory from C# using unsafe code? And as a corollary, is it safe to catch AccessViolationExceptions from unsafe code?

Answer 1

You are missing the Big Bullet:

• accessing memory and not getting an AccessViolationException.

Which is very common, there's always lots of writable memory around in a .NET program. Including writing the element beyond the end of an array, it rarely bombs. Memory protection is granular at memory page boundaries, 4096 bytes on Windows. The .NET GC bumps that up considerably, the generational heap segments are nice big hunks of VM. Catching AVEs is very unwise.

Some code to play with:

class Program {
    static unsafe void Main(string[] args) {
        var arr = new byte[1];
        for (int fill = 0; fill < 2 * 1024 - 64; ++fill) {
            byte[] dummy = new byte[1024];
        }
        fixed (byte* p = &arr[0]) {
            for (int ix = 1; ; ++ix)
                p[ix] = 42;
        }
    }
}

Overshoots by about 1.5 megabytes.