以下为引用的内容：

            byte[] inputBuffer = new byte[1024];

                Stopwatch stopWatch = new Stopwatch();

                using (AweStream.AweStream aweStream = new AweStream.AweStream(1024 * 1024 * 100))
                {
                    //Map
                    aweStream.Map();
                    stopWatch.Start();

                    //Copy one bytes
                    //Use unsafe pointer
                    for (int i = 0; i < 1024 * 1024 * 100; i++)
                    {
                        unsafe
                        {
                            aweStream.LpMemory[i] = 1;
                        }
                    }

                    stopWatch.Stop();

                    Console.WriteLine(stopWatch.ElapsedMilliseconds);

                    aweStream.Position = 0;

                   
                    //Block copy
                    stopWatch.Reset();
                    stopWatch.Start();

                    for (int i = 0; i < 1024 * 100; i++)
                    {
                        unsafe
                        {
                            aweStream.Write(inputBuffer, 0, 1024);
                        }
                    }

                    stopWatch.Stop();

                    Console.WriteLine(stopWatch.ElapsedMilliseconds);

                    //UnMap
                    aweStream.UnMap();
                }

以下为引用的内容：

        public AweStream(UInt32 capacity)
        {
            unsafe
            {
                // Enable the privilege of lock memory.

                lock (_SetLockPagesPrivilegeLockObj)
                {
                    if (!_SetLockPagesPrivilegeOk)
                    {
                        LoggedSetLockPagesPrivilege.SetLockPagesPrivilege(System.Diagnostics.Process.GetCurrentProcess(), true);
                        _SetLockPagesPrivilegeOk = true;
                    }
                }

                General.SYSTEM_INFO sysInfo;
                General.GetSystemInfo(out sysInfo);  // fill the system information structure

                _PageSize = sysInfo.dwPageSize;
                if ((capacity % _PageSize) != 0)
                {
                    _NumberOfPages = capacity / _PageSize + 1;
                }
                else
                {
                    _NumberOfPages = capacity / _PageSize;
                }

                _PFNArraySize = (UInt32)(_NumberOfPages * sizeof(UInt64*));               // memory to request for PFN array

                _PFNArray = Marshal.AllocHGlobal((int)_PFNArraySize);

                UInt32 numberOfPagesInitial = _NumberOfPages;

                if (!AweApi.AllocateUserPhysicalPages(System.Diagnostics.Process.GetCurrentProcess().Handle,
                    ref _NumberOfPages, _PFNArray))
                {
                    Dispose();
                    throw new AweStreamException("Cannot allocate physical pages", AweStreamException.Reason.CannotAllocatePhysicalPages);
                }

                _AweAllocated = true;

                if (numberOfPagesInitial != _NumberOfPages)
                {
                    Dispose();
                    throw new AweStreamException(string.Format("Allocated only {0} pages.", _NumberOfPages),
                         AweStreamException.Reason.AweMemoryNotEnough);
                }

                _Capacity = _PageSize * _NumberOfPages;
            }

        }

以下为引用的内容：

        public void Map(bool readOnly)
        {
            unsafe
            {
                if (IsMapped)
                {
                    return;
                }

                if (readOnly)
                {
                    _VirtualAddress = AweApi.VirtualAlloc(null, Capacity, AweApi.MEM_RESERVE | AweApi.MEM_PHYSICAL,
                                        AweApi.PAGE_READONLY);
                }
                else
                {
                    _VirtualAddress = AweApi.VirtualAlloc(null, Capacity, AweApi.MEM_RESERVE | AweApi.MEM_PHYSICAL,
                                        AweApi.PAGE_READWRITE);
                }

                if (_VirtualAddress == null)
                {
                    throw new AweStreamException("Cannot reserve memory.", AweStreamException.Reason.CannotReserveMemory);
                }

                if (!AweApi.MapUserPhysicalPages(_VirtualAddress, _NumberOfPages, _PFNArray))
                {
                    AweApi.VirtualFree(_VirtualAddress, Capacity, AweApi.MEM_RELEASE);
                    _VirtualAddress = null;
                    throw new AweStreamException(string.Format("MapUserPhysicalPages failed ({0})", General.GetLastError()),
                        AweStreamException.Reason.MapUserPhysicalPagesFail);
                }

                _CanWrite = !readOnly;
            }
        }