public static void VirtualMemorySetProtection(void* pointer, IntPtr size, MemoryProtection protection)
 {
     int old;
     switch (protection)
     {
         case MemoryProtection.Execute:
             Kernel32.VirtualProtect(pointer, size, Kernel32.VirtualMemProtectionFlag.PageExecute, out old);
             break;
         case MemoryProtection.ReadWrite:
             Kernel32.VirtualProtect(pointer, size, Kernel32.VirtualMemProtectionFlag.PageReadWrite, out old);
             break;
     }
 }

 public PhysicalPagesMapping Map(IntPtr address, MemoryProtection protection)
 {
     IntPtr allocAddress = ProcessHandle.Current.AllocateMemory(
         address,
         _count * Windows.PageSize,
         MemoryFlags.Reserve | MemoryFlags.Physical,
         protection
         );
     if (!Win32.MapUserPhysicalPages(
         allocAddress,
         new IntPtr(_count),
         _pfnArray
         ))
         Win32.ThrowLastError();
     return new PhysicalPagesMapping(this, allocAddress);
 }

        public MemoryMappedFileStream(string name, uint maxLength, MemoryProtection protection)
        {
            if(string.IsNullOrEmpty(name))
            {
                throw(new ArgumentException("Argument_Name"));
            }

            if(maxLength < 0)
            {
                throw(new ArgumentOutOfRangeException("ArgumentOutOfRange_MaxLength"));
            }

            objectName = name;

            if (protection < MemoryProtection.PageNoAccess ||
                protection > MemoryProtection.SecReserve)
            {
                throw new ArgumentOutOfRangeException("ArgumentOutOfRange_Enum");
            }

            if( maxLength == 0 )
            {
                mapLength = 5120;
            }
            else
            {
                mapLength = maxLength;
            }

            memProtection = protection;

            isReadable = true;
            isWritable = true;
            isSeekable = true;

            // Initialize mapViewPointer
            mapViewPointer = new IntPtr(-1);

            SECURITY_ATTRIBUTES sa = SECURITY_ATTRIBUTES.GetNullDacl();
            try
            {
                mapHandle = MemoryMappedFileHelper.CreateFileMapping(
                                                    IntPtr.Zero,
                                                    sa,
                                                    memProtection,
                                                    0,
                                                    mapLength,
                                                    objectName);
            }
            finally
            {
                Marshal.FreeHGlobal(sa.lpSecurityDescriptor);
                sa.lpSecurityDescriptor = IntPtr.Zero;
            }

            if(mapHandle == IntPtr.Zero )
            {
                uint lastError = MemoryMappedFileHelper.GetLastError();
                throw new IOException(
                    MemoryMappedFileHelper.GetWin32ErrorMessage( lastError ) );
            }
        }

 internal static extern IntPtr VirtualAllocEx(SafeProcessHandle processHandle, IntPtr address, SizeT size, AllocationType flAllocationType,
     MemoryProtection flProtect);

 static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, IntPtr dwSize, AllocationType flAllocationType, MemoryProtection flProtect);

        public static Win32FileMapAccess GetWin32FileMapAccess( 
			MemoryProtection protection )
        {
            switch ( protection )
            {
                case MemoryProtection.PageReadOnly:
                    return Win32FileMapAccess.FILE_MAP_READ;
                case MemoryProtection.PageWriteCopy:
                    return Win32FileMapAccess.FILE_MAP_WRITE;
                default:
                    return Win32FileMapAccess.FILE_MAP_ALL_ACCESS;
            }
        }

 internal static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress, IntPtr dwSize, MemoryProtection flNewProtect, ref MemoryProtection lpflOldProtect);

 public PhysicalPagesMapping Map(MemoryProtection protection)
 {
     return this.Map(IntPtr.Zero, protection);
 }

		public static extern bool VirtualProtectEx(
			IntPtr hProcess,
			IntPtr lpAddress,
			uint dwSize,
			MemoryProtection flNewProtect,
			[Out] MemoryProtection lpflOldProtect);

 public static void VirtualMemorySetProtection(void* pointer, IntPtr size, MemoryProtection protection)
 {
     NativeUtilsImplementation.VirtualMemorySetProtection(pointer, size, protection);
 }

 public static extern bool VirtualProtect(IntPtr address, uint size, MemoryProtection newProtect, out MemoryProtection oldProtect);

 public static extern int VirtualAllocEx(IntPtr hProcess, Int32 lpAddress,
    Int32 dwSize, AllocationType flAllocationType, MemoryProtection flProtect);

 public static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress, int nSize, MemoryProtection flNewProtect, out MemoryProtection lpflOldProtect);

 /// <summary>
 /// Reserves, commits, or changes the state of a region of pages in the virtual address space of the calling process.
 /// Memory allocated by this function is automatically initialized to zero.
 /// </summary>
 /// <param name="sizeInBytes">The size of the region, in bytes</param>
 /// <param name="allocationType">The type of memory allocation.</param>
 /// <param name="protection">The memory protection for the region of pages to be allocated.</param>
 /// <returns>The base address of the allocated region of pages.</returns>
 public static void* VirtualAlloc(ulong sizeInBytes, MemoryAllocationType allocationType, MemoryProtection protection)
 {
     var pointer = VirtualAlloc(IntPtr.Zero, new UIntPtr(sizeInBytes), allocationType, protection).ToPointer();
     if (pointer == null)
         throw new InvalidOperationException(Marshal.GetLastWin32Error().ToString());
     return pointer;
 }

 public static extern DWORD_PTR VirtualAllocEx( IntPtr hProcess, DWORD_PTR lpAddress, uint dwSize, AllocationType flAllocationType, MemoryProtection flProtect );

 internal static extern IntPtr VirtualAllocEx(SafeProcessHandle hProcess, uint dwAddress, int nSize, AllocationType dwAllocationType, MemoryProtection dwProtect);

        public MemoryFileSystem(string fileName, MfsOpenMode mode, bool readOnly, MfsParameters createParams)
        {
            FileCreationDispositionWin32 cdWin32;

            if (readOnly && mode != MfsOpenMode.Open)
                throw new ArgumentException("Invalid mode for read only access.");

            switch (mode)
            {
                case MfsOpenMode.Open:
                    cdWin32 = FileCreationDispositionWin32.OpenExisting;
                    break;
                default:
                case MfsOpenMode.OpenIf:
                    cdWin32 = FileCreationDispositionWin32.OpenAlways;
                    break;
                case MfsOpenMode.OverwriteIf:
                    cdWin32 = FileCreationDispositionWin32.CreateAlways;
                    break;
            }

            using (FileHandle fhandle = FileHandle.CreateWin32(
                fileName,
                FileAccess.GenericRead | (!readOnly ? FileAccess.GenericWrite : 0),
                FileShareMode.Read,
                cdWin32
                ))
            {
                bool justCreated = false;

                _readOnly = readOnly;
                _protection = !readOnly ? MemoryProtection.ReadWrite : MemoryProtection.ReadOnly;

                if (fhandle.FileSize == 0)
                {
                    if (readOnly)
                    {
                        throw new MfsInvalidFileSystemException();
                    }
                    
                    // File is too small. Make it 1 byte large and we'll deal with it soon.
                    fhandle.SetEnd(1);
                }

                _section = new Section(fhandle, _protection);

                _blockSize = MfsBlockSizeBase; // fake block size to begin with; we'll fix it up later.

                if (fhandle.FileSize < _blockSize)
                {
                    if (readOnly)
                    {
                        throw new MfsInvalidFileSystemException();
                    }
                    
                    // We're creating a new file system. We need the correct block size now.
                    if (createParams != null)
                        this._blockSize = createParams.BlockSize;
                    else
                        this._blockSize = MfsDefaultBlockSize;

                    this._section.Extend(this._blockSize);

                    using (SectionView view = this._section.MapView(0, this._blockSize, this._protection))
                    {
                        this.InitializeFs((MfsFsHeader*)view.Memory, createParams);
                    }

                    justCreated = true;
                }

                _header = (MfsFsHeader*)this.ReferenceBlock(0);

                // Check the magic.
                if (_header->Magic != MfsMagic)
                    throw new MfsInvalidFileSystemException();

                // Set up the local constants.
                _blockSize = _header->BlockSize;
                _cellSize = _header->CellSize;

                // Backwards compatibility.
                if (_blockSize == 0)
                    _blockSize = MfsDefaultBlockSize;
                if (_cellSize == 0)
                    _cellSize = MfsDefaultCellSize;

                // Validate the parameters.
                this.ValidateFsParameters(_blockSize, _cellSize);

                _blockMask = _blockSize - 1;
                _cellCount = _blockSize / _cellSize;
                _dataCellDataMaxLength = _cellSize - MfsDataCell.DataOffset;

                // Remap block 0 with the correct block size.
                this.DereferenceBlock(0);

                // If we just created a new file system, fix the section size.
                if (justCreated)
                    _section.Extend(_blockSize);
//.........这里部分代码省略.........

 public static extern IntPtr VirtualAlloc(IntPtr blockAddress, UIntPtr sizeInBytes,
     MemoryAllocationType allocationType, MemoryProtection protection);

 public static extern bool VirtualProtect(IntPtr lpAddress, uint dwSize,
    MemoryProtection flNewProtect, out MemoryProtection lpflOldProtect);

        public void Protect(SafeProcessHandle handle, uint offset, uint size, MemoryProtection newProtect)
        {
            if (Address == IntPtr.Zero)
                throw new ObjectDisposedException("RemoteMemoryRegion");
            if ((offset + size) > (Size))
                throw new ArgumentException("Size too large for region");

            MemoryProtection oldProtect;
            int result = Win32.VirtualProtectEx(
                handle.DangerousGetHandle(),
                (uint)(Address.ToInt64() + offset),
                size, newProtect, out oldProtect
            );

            if (result == 0) {
                var error = Win32.GetLastError();
                throw new Exception(String.Format("Protect failed: Error {0:x8}", error));
            }
        }