private void openOrCreateMemoryAndWriteData <T>(T data) { mutex.WaitOne(); try { mapFile = MemoryMappedFile.Open(MapAccess.FileMapAllAccess, fileName); } catch { mapFile = MemoryMappedFile.Create(MapProtection.PageReadWrite, 8 * 1024, fileName); } Stream writer = mapFile.MapView(MapAccess.FileMapAllAccess, 0, 8 * 1024); char[] charArrayOfObject = serializeToXml <T>(data).ToCharArray(); for (int i = 0; i < charArrayOfObject.Length; i++) { writer.WriteByte((byte)charArrayOfObject[i]); } writer.Flush(); writer.Close(); mutex.ReleaseMutex(); }
private void readDataFromMemory() { if (mapFile == null) { try { mapFile = MemoryMappedFile.Open(MapAccess.FileMapAllAccess, fileName); } catch { mapFile = null; throw new Exception("File " + fileName + " is not opened yet."); } } try { reader = mapFile.MapView(MapAccess.FileMapRead, 0, 8 * 1024); } catch (Exception) { Debug.WriteLine("Error in Reading"); } getObjectFromMMF <TestData>(); }
/// <summary> /// Create a named map object /// </summary> /// <param name="fileName">name of backing file, or null /// for a pagefile-backed map</param> /// <param name="protection">desired access to the mapping /// object</param> /// <param name="maxSize">maximum size of filemap object, or 0 /// for size of file</param> /// <param name="name">name of file mapping object</param> /// <returns>The memory mapped file instance</returns> public static MemoryMappedFile Create( string fileName, MapProtection protection, long maxSize, String name) { MemoryMappedFile map = new MemoryMappedFile(); // open file first IntPtr hFile = INVALID_HANDLE_VALUE; if ( fileName != null ) { // determine file access needed // we'll always need generic read access int desiredAccess = GENERIC_READ; if ( (protection == MapProtection.PageReadWrite) || (protection == MapProtection.PageWriteCopy) ) { desiredAccess |= GENERIC_WRITE; } // open or create the file // if it doesn't exist, it gets created hFile = Win32MapApis.CreateFile ( fileName, desiredAccess, 0, IntPtr.Zero, OPEN_ALWAYS, 0, IntPtr.Zero ); if ( hFile == INVALID_HANDLE_VALUE ) throw new FileMapIOException ( Marshal.GetHRForLastWin32Error() ); // FIX: Is support neede for zero-length files!?! } map._hMap = Win32MapApis.CreateFileMapping ( hFile, IntPtr.Zero, (int)protection, (int)((maxSize >> 32) & 0xFFFFFFFF), (int)(maxSize & 0xFFFFFFFF), name ); // close file handle, we don't need it if ( hFile != INVALID_HANDLE_VALUE ) Win32MapApis.CloseHandle(hFile); if ( map._hMap == NULL_HANDLE ) throw new FileMapIOException ( Marshal.GetHRForLastWin32Error() ); return map; }
/// <summary> /// Open an existing named File Mapping object /// </summary> /// <param name="access">desired access to the map</param> /// <param name="name">name of object</param> /// <returns>The memory mapped file instance</returns> public static MemoryMappedFile Open( MapAccess access, String name ) { MemoryMappedFile map = new MemoryMappedFile(); map._hMap = Win32MapApis.OpenFileMapping ( (int)access, false, name ); if ( map._hMap == NULL_HANDLE ) throw new FileMapIOException ( Marshal.GetHRForLastWin32Error() ); return map; }
Create(string fileName, MapProtection protection, long maxSize, String name) { MemoryMappedFile map = new MemoryMappedFile(); if (!map.Is64bit && maxSize > uint.MaxValue) throw new ConstraintException("32bit systems support max size of 4gb."); // open file first IntPtr hFile = INVALID_HANDLE_VALUE; if (!string.IsNullOrEmpty(fileName)) { if (maxSize == 0) { if (!File.Exists(fileName)) { throw new Exception(string.Format("Winterdom.IO.FileMap.MemoryMappedFile.Create - \"{0}\" does not exist ==> Unable to map entire file", fileName)); } FileInfo backingFileInfo = new FileInfo(fileName); maxSize = backingFileInfo.Length; if (maxSize == 0) { throw new Exception(string.Format("Winterdom.IO.FileMap.MemoryMappedFile.Create - \"{0}\" is zero bytes ==> Unable to map entire file", fileName)); } } // determine file access needed // we'll always need generic read access int desiredAccess = GENERIC_READ; if ((protection == MapProtection.PageReadWrite) || (protection == MapProtection.PageWriteCopy)) { desiredAccess |= GENERIC_WRITE; } // open or create the file // if it doesn't exist, it gets created hFile = Win32MapApis.CreateFile( fileName, desiredAccess, 0, IntPtr.Zero, OPEN_ALWAYS, 0, IntPtr.Zero ); if (hFile == INVALID_HANDLE_VALUE) throw new FileMapIOException(Marshal.GetHRForLastWin32Error()); //SafeFileHandle handle = new SafeFileHandle(hFile,true); //NTFS.Sparse.SparseFile.MarkSparse(handle); map._fileName = fileName; } map._hMap = Win32MapApis.CreateFileMapping( hFile, IntPtr.Zero, (int)protection, (int)((maxSize >> 32) & 0xFFFFFFFF), (int)(maxSize & 0xFFFFFFFF), name ); // close file handle, we don't need it if (hFile != INVALID_HANDLE_VALUE) Win32MapApis.CloseHandle(hFile); if (map._hMap == NULL_HANDLE) throw new FileMapIOException(Marshal.GetHRForLastWin32Error()); map._protection = protection; map._maxSize = maxSize; return map; }
Create(string fileName, MapProtection protection, long maxSize, String name) { MemoryMappedFile map = new MemoryMappedFile(); if (!map.Is64bit && maxSize > uint.MaxValue) { throw new ConstraintException("32bit systems support max size of 4gb."); } // open file first IntPtr hFile = INVALID_HANDLE_VALUE; if (!string.IsNullOrEmpty(fileName)) { if (maxSize == 0) { if (!File.Exists(fileName)) { throw new Exception(string.Format("Winterdom.IO.FileMap.MemoryMappedFile.Create - \"{0}\" does not exist ==> Unable to map entire file", fileName)); } FileInfo backingFileInfo = new FileInfo(fileName); maxSize = backingFileInfo.Length; if (maxSize == 0) { throw new Exception(string.Format("Winterdom.IO.FileMap.MemoryMappedFile.Create - \"{0}\" is zero bytes ==> Unable to map entire file", fileName)); } } // determine file access needed // we'll always need generic read access int desiredAccess = GENERIC_READ; if ((protection == MapProtection.PageReadWrite) || (protection == MapProtection.PageWriteCopy)) { desiredAccess |= GENERIC_WRITE; } // open or create the file // if it doesn't exist, it gets created hFile = Win32MapApis.CreateFile( fileName, desiredAccess, 0, IntPtr.Zero, OPEN_ALWAYS, 0, IntPtr.Zero ); if (hFile == INVALID_HANDLE_VALUE) { throw new FileMapIOException(Marshal.GetHRForLastWin32Error()); } //SafeFileHandle handle = new SafeFileHandle(hFile,true); //NTFS.Sparse.SparseFile.MarkSparse(handle); map._fileName = fileName; } map._hMap = Win32MapApis.CreateFileMapping( hFile, IntPtr.Zero, (int)protection, (int)((maxSize >> 32) & 0xFFFFFFFF), (int)(maxSize & 0xFFFFFFFF), name ); // close file handle, we don't need it if (hFile != INVALID_HANDLE_VALUE) { Win32MapApis.CloseHandle(hFile); } if (map._hMap == NULL_HANDLE) { throw new FileMapIOException(Marshal.GetHRForLastWin32Error()); } map._protection = protection; map._maxSize = maxSize; return(map); }
/// <summary> /// Constructor used internally by MemoryMappedFile. /// </summary> /// <param name="backingFile">Preconstructed MemoryMappedFile</param> /// <param name="mapSize">Size of the view, in bytes.</param> /// <param name="isWriteable">True if Read/Write access is desired, False otherwise</param> internal MapViewStream(MemoryMappedFile backingFile, long mapSize, bool isWriteable) { if (backingFile == null) { throw new Exception("MapViewStream.MapViewStream - backingFile is null"); } if (!backingFile.IsOpen) { throw new Exception("MapViewStream.MapViewStream - backingFile is not open"); } if ((mapSize < 1) || (mapSize > backingFile.MaxSize)) { throw new Exception(string.Format("MapViewStream.MapViewStream - mapSize is invalid. mapSize == {0}, backingFile.MaxSize == {1}", mapSize, backingFile.MaxSize)); } _backingFile = backingFile; _isWriteable = isWriteable; _access = isWriteable ? MapAccess.FileMapWrite : MapAccess.FileMapRead; // Need a backingFile.SupportsAccess function that takes a MapAccess compares it against its stored MapProtection protection and returns bool _mapSize = mapSize; _isOpen = true; // Map the first view Seek(0, SeekOrigin.Begin); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="T:PeFileProcessor"/> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// ------------------------------------------------------------------------------------ public PeFileProcessor(string fileName) { m_htDirectories = new Hashtable(); m_fileName = fileName; m_mappedFile = MemoryMappedFile.Create(fileName, MapProtection.PageWriteCopy); ProcessFile(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Performs application-defined tasks associated with freeing, releasing, or /// resetting unmanaged resources. /// </summary> /// <param name="fFromDispose">if set to <c>true</c> called from Dispose() - safe /// to do stuff with managed objects; if <c>false</c> called from Finalizer - managed /// objects might already be disposed.</param> /// ------------------------------------------------------------------------------------ protected virtual void Dispose(bool fFromDispose) { if (fFromDispose) { if (m_reader != null) m_reader.Close(); if (m_writer != null) m_writer.Close(); if (m_stream != null) m_stream.Dispose(); if (m_mappedFile != null) m_mappedFile.Dispose(); } m_reader = null; m_writer = null; m_stream = null; m_mappedFile = null; }