[StructLayout(LayoutKind.Sequential)]
public struct ColorRef
{
    public byte Red;
    public byte Green;
    public byte Blue;
    private byte Unused;

    public ColorRef(byte red, byte green, byte blue) : this()
    {
        Red = red;
        Green = green;
        Blue = blue;
        Unused = 0;
    }
}

public class VirtualMemoryManger
{
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool VirtualFreeEx(IntPtr hProcess, IntPtr lpAddress, IntPtr dwSize, IntPtr dwFreeType);

    [DllImport("kernel32.dll", EntryPoint = "GetCurrentProcess")]
    internal static extern IntPtr GetCurrentProcessHandle();

    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, IntPtr dwSize, AllocationType flAllocationType, uint flProtect);

    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool VirtualProtectEx(IntPtr hPorcess, IntPtr lpAddress, IntPtr dwSize, uint flNewProtect, ref uint lpflOldProtect);

    public static IntPtr AllocExecutionBlock(int size, IntPtr hProcess)
    {
        IntPtr codeBytesPtr = VirtualAllocEx(hProcess, IntPtr.Zero, (IntPtr)size, AllocationType.Reserve | AllocationType.Commit, (uint)ProtectionOptions.PageExecuteReadWrite);
        if (codeBytesPtr == IntPtr.Zero)
        {
            throw new Win32Exception();
        }
        uint lpflOldProtect = 0;
        if (!VirtualProtectEx(hProcess, codeBytesPtr, (IntPtr)size, (uint)ProtectionOptions.PageExecuteReadWrite, ref lpflOldProtect))
        {
            throw new Win32Exception();
        }
        return codeBytesPtr;
    }

    public static IntPtr AllocExecutionBlock(int size)
    {
        //通常应该将方法封装到公共包装里面，从而降低P/Invoke API调用的复杂性，这样可以增强API的可用性，同时更有利于转向面向对象的类型结构。
        return AllocExecutionBlock(size, GetCurrentProcessHandle());
    }

    public static bool VirtualFreeEx(IntPtr hProcess, IntPtr lpAddress, IntPtr dwSize)
    {
        bool result = VirtualFreeEx(hProcess, lpAddress, dwSize, (IntPtr)MemoryFreeType.Decommit);
        if (!result)
        {
            throw new Win32Exception();
        }
        return result;
    }

    public static bool VirtualFreeEx(IntPtr lpAddress, IntPtr dwSize)
    {
        //无论错误处理、struct、还是常量值，优秀的API开发人员都应该提供一个简化的托管API，降低层的Win32API包装起来。
        return VirtualFreeEx(GetCurrentProcessHandle(), lpAddress, dwSize);
    }
}

public class VirtualMemoryPtr:SafeHandle
{
    public readonly IntPtr AllocatedPointer;
    private readonly IntPtr ProcessHandle;
    private readonly IntPtr MemorySize;
    private bool Disposed;
    public VirtualMemoryPtr(int memorySize) : base(IntPtr.Zero, true)
    {
        ProcessHandle = VirtualMemoryManger.GetCurrentProcessHandle();
        MemorySize = (IntPtr) memorySize;
        AllocatedPointer = VirtualMemoryManger.AllocExecutionBlock(memorySize, ProcessHandle);
        Disposed = false;
    }

    public static implicit operator IntPtr(VirtualMemoryPtr virtualAMemoryPointer)
    {
        return virtualAMemoryPointer.AllocatedPointer;
    }

    protected override bool ReleaseHandle()
    {
        if (!Disposed)
        {
            Disposed = true;
            GC.SuppressFinalize(this);
            VirtualMemoryManger.VirtualFreeEx(ProcessHandle,AllocatedPointer,MemorySize);
        }
        return true;
    }

    public override bool IsInvalid { get { return Disposed; } }
}

[Flags]
public enum AllocationType
{
    Reserve = 0x2000,
    Commit = 0x1000,
    Reset = 0x8000,
    Physical = 0x400000,
    TopDown = 0x100000,
}

[Flags]
public enum ProtectionOptions
{
    PageExecuteReadWrite = 0x40,
    PageExecuteRead = 0x20,
    Execute = 0x10
}

[Flags]
public enum MemoryFreeType
{
    Decommit = 0x4000,
    Release = 0x8000
}