MemoryFailPoint

A complex algorithm requires considerable memory—and the system should ensure it has enough before even attempting to run the algorithm.

With MemoryFailPoint, an exception is thrown if there is not enough memory. We pass an int to MemoryFailPoint. This is the number of required megabytes of memory.

An example

This program shows the MemoryFailPoint in a situation where it will always throw an exception. It tries to ensure the system has 1 million megabytes of RAM.

using System.Runtime;

class Program
{
    static void Main()
    {
        // This program for some reason needs a huge amount of memory.
        using (MemoryFailPoint point = new MemoryFailPoint(1000000))
        {
            // An exception is thrown at this point.
            // ... The computer does not have enough memory.
            // ... So we do not need to execute the inner code.
        }
    }
}
Unhandled Exception: System.InsufficientMemoryException:
    Insufficient memory to meet the expected demands of an operation,
    and this system is likely to never satisfy this request.
    If this is a 32 bit system, consider booting in 3 GB mode.
   at System.Runtime.MemoryFailPoint..ctor(Int32 sizeInMegabytes)
   at Program.Main()...

Some notes

In complex systems, MemoryFailPoint can help improve reliability. We can avoid starting a method if we estimate it will not be able to finish.

Notes, reliability

For methods that are critical and require large amounts of RAM, MemoryFailPoint is probably something that should always be used.

A summary

With MemoryFailPoint, we improve complex systems by causing "early failures" instead of possibly causing worse problems because a method starts (but does not finish) its work.