/// <summary> /// Load the configuration file (if it exists). /// </summary> /// <param name="configuration_file">path to the configuration file</param> public static Configuration?LoadConfiguration(string configuration_file) { XmlSerializer?serializer = new XmlSerializer(typeof(Configuration)); FileStream? fileStream = null; try { fileStream = new FileStream(configuration_file, FileMode.Open); } catch (Exception e) { DebugUtilities.WriteError("Could not open configuration file; error was: " + e.Message); Environment.Exit(1); } try { // fileStream/serializer are now nullable; return null if that's the case. (gwyneth 20220127) if (fileStream != null && serializer != null) { fileStream.Seek(0, SeekOrigin.Begin); return((Configuration?)serializer.Deserialize(fileStream)); } } catch (Exception e) { DebugUtilities.WriteError("Could not parse XML file - error was: " + e.Message); Environment.Exit(1); // this is overkill... we might be able to deal with most errors using reasonable defaults... (gwyneth 20220127) } return(null); } // end constructor
public async Task DeviceInterfaceCanBeOpenedForAsyncIO() { FileStream?fileStream = OpenFirstAvailableDeviceInterface(); if (fileStream is null) { // it's OK to not have any such devices available // this test is just best effort return; } using (fileStream) { Assert.True(fileStream.CanRead); Assert.False(fileStream.CanWrite); Assert.False(fileStream.CanSeek); // #54143 try { CancellationTokenSource cts = new(TimeSpan.FromMilliseconds(250)); await fileStream.ReadAsync(new byte[4096], cts.Token); } catch (OperationCanceledException) { // most likely there is no data available and the task is going to get cancelled // which is fine, we just want to make sure that reading from devices is supported (#54143) } } }
public static EdgeSpanStream Load(string filePath) { FileStream?stream = null; try { stream = File.OpenRead(filePath); using var reader = new BinaryReader(stream, Encoding.ASCII, leaveOpen: true); var readHeader = reader.ReadString();; if (readHeader != HeaderText) { throw new InvalidOperationException($"Unsupported edge span file format: {filePath}"); } var viewPort = reader.ReadViewPort(); var computationType = (ComputationType)reader.ReadInt32(); var count = reader.ReadInt32(); Log.Info($"Loaded edge spans with resolution ({viewPort.Resolution.Width:N0}x{viewPort.Resolution.Height:N0}), " + $"area {viewPort.Area}, and {count:N0} edge spans."); return(new EdgeSpanStream(viewPort, computationType, count, stream)); } catch (Exception) { stream?.Dispose(); throw; } }
/// <summary>Updates the collection of files</summary> public void SetFiles(IEnumerable <string> filepaths) { Files.Clear(); foreach (var f in filepaths) { Files.Add(new FileInfo(f)); } // Determine the combined file length m_total_length = 0; m_boundary.Clear(); foreach (var f in Files) { m_total_length += f.Length; m_boundary.Add(m_total_length); } m_boundary.Add(m_total_length); // Add an extra one to avoid extra ifs // Reset the file position m_position = 0; m_fs = null; m_fs_index = -1; // Force 'FileStream' to be created so that a lock is held from construction var _ = FileStream; }
public virtual void ReadModule() { tempAssembly = $"{AssemblyFilePath}.tmp"; File.Copy(AssemblyFilePath, tempAssembly, true); if (debugReaderProvider != null && DebugSymbols != DebugSymbolsType.Embedded) { tempSymbols = $"{pdbPath}.tmp"; if (File.Exists(pdbPath)) { File.Copy(pdbPath, tempSymbols, true); SymbolStream = FileEx.OpenRead(tempSymbols); } } var readerParameters = new ReaderParameters { AssemblyResolver = assemblyResolver, ReadSymbols = SymbolStream != null || DebugSymbols == DebugSymbolsType.Embedded, SymbolReaderProvider = debugReaderProvider, SymbolStream = SymbolStream, }; ModuleDefinition = ModuleDefinition.ReadModule(tempAssembly, readerParameters); }
/// <summary> /// Used by the 2 Create factory method groups. A null fileHandle specifies that the /// memory mapped file should not be associated with an existing file on disk (i.e. start /// out empty). /// </summary> private static SafeMemoryMappedFileHandle CreateCore( FileStream?fileStream, string?mapName, HandleInheritability inheritability, MemoryMappedFileAccess access, MemoryMappedFileOptions options, long capacity) { SafeFileHandle?fileHandle = fileStream != null ? fileStream.SafeFileHandle : null; Interop.Kernel32.SECURITY_ATTRIBUTES secAttrs = GetSecAttrs(inheritability); SafeMemoryMappedFileHandle handle = fileHandle != null? Interop.CreateFileMapping(fileHandle, ref secAttrs, GetPageAccess(access) | (int)options, capacity, mapName) : Interop.CreateFileMapping(new IntPtr(-1), ref secAttrs, GetPageAccess(access) | (int)options, capacity, mapName); int errorCode = Marshal.GetLastWin32Error(); if (!handle.IsInvalid) { if (errorCode == Interop.Errors.ERROR_ALREADY_EXISTS) { handle.Dispose(); throw Win32Marshal.GetExceptionForWin32Error(errorCode); } } else // handle.IsInvalid { handle.Dispose(); throw Win32Marshal.GetExceptionForWin32Error(errorCode); } return(handle); }
internal static bool TryOpen(string path, out FileStream?stream) { if (IsWindows) { var handle = CreateFile(path, ACCESS_MASK.GenericRight.GENERIC_READ, FileShare.FILE_SHARE_READ, (SECURITY_ATTRIBUTES?)null, CreationDisposition.OPEN_EXISTING, CreateFileFlags.FILE_ATTRIBUTE_NORMAL, SafeObjectHandle.Null); if (!handle.IsInvalid) { var fileHandle = new SafeFileHandle(handle.DangerousGetHandle(), ownsHandle: true); handle.SetHandleAsInvalid(); stream = new FileStream(fileHandle, System.IO.FileAccess.Read); return(true); } else { stream = null; return(false); } } else { if (!File.Exists(path)) { stream = null; return(false); } stream = File.OpenRead(path); return(true); } }
public async Task <IActionResult> Upload(IFormFileCollection files) { var folder = new DirectoryInfo(Path.Combine(environment.ContentRootPath, "media", DateTime.Now.ToString("yyMM"))); folder.Create(); var status = new List <(string name, bool success)>(capacity: files.Count); foreach (IFormFile file in files) { FileInfo physical = new FileInfo(Path.Combine(folder.FullName, file.FileName)); FileStream?stream = null; try { stream = new FileStream(physical.FullName, FileMode.CreateNew, FileAccess.Write, FileShare.None); await file.CopyToAsync(stream); status.Add((file.FileName, true)); } catch (IOException) { status.Add((file.FileName, false)); } finally { if (stream != null) { await stream.DisposeAsync(); } } } return(View("Uploaded", new MediaUploadViewModel(status))); }
/// <inheritdoc /> public new void Dispose() { lock (_lock) { _openStream?.Dispose(); _openStream = null; } }
internal static bool TryOpen(string path, out FileStream?stream) { if (IsWindows) { var handle = PInvoke.CreateFile(path, FILE_ACCESS_FLAGS.FILE_GENERIC_READ, FILE_SHARE_MODE.FILE_SHARE_READ, lpSecurityAttributes: null, FILE_CREATION_DISPOSITION.OPEN_EXISTING, FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_NORMAL, null); if (!handle.IsInvalid) { var fileHandle = new SafeFileHandle(handle.DangerousGetHandle(), ownsHandle: true); handle.SetHandleAsInvalid(); stream = new FileStream(fileHandle, System.IO.FileAccess.Read); return(true); } else { stream = null; return(false); } } else { if (!File.Exists(path)) { stream = null; return(false); } stream = File.OpenRead(path); return(true); } }
public static Task <List <GlobalFindResult> > Find(string rootDirectory, string text, string[] extensions) { ConcurrentBag <GlobalFindResult> res = new(); Parallel.ForEach(extensions, (ex) => { foreach (string?file in Directory.GetFiles(rootDirectory, ex, SearchOption.AllDirectories)) { using FileStream? f = File.OpenRead(file); int line = 1; using StreamReader sr = new(f); string?lineText = null; while ((lineText = sr.ReadLine()) != null) { if (lineText.Contains(text, System.StringComparison.InvariantCultureIgnoreCase)) { res.Add(new GlobalFindResult(file, line, lineText, text)); } line++; } } }); return(Task.FromResult(res.OrderBy(p => p.FileName).ThenBy(p => p.LineNumber).ToList())); }
/// <summary> /// 把对象序列化到二进制文件中 /// </summary> /// <param name="objToSave">欲保存的对象</param> /// <param name="filename">包含路径的文件名</param> public static void Serialize(object objToSave, string filename) { FileStream?fs = null; try { fs = new FileStream(filename, FileMode.Create); Serialize(objToSave, fs); DebugHelper.WriteLine("into binary file: " + filename); } catch (Exception ex) { fs?.Close(); fs?.Dispose(); fs = null; try { File.Delete(filename); } finally { throw ex; } } finally { fs?.Close(); fs?.Dispose(); } }
/// <summary>Initializes the memory-mapped file handle.</summary> /// <param name="fileStream">The underlying file stream; may be null.</param> /// <param name="ownsFileStream">Whether this SafeHandle is responsible for Disposing the fileStream.</param> /// <param name="inheritability">The inheritability of the memory-mapped file.</param> /// <param name="access">The access for the memory-mapped file.</param> /// <param name="options">The options for the memory-mapped file.</param> /// <param name="capacity">The capacity of the memory-mapped file.</param> internal SafeMemoryMappedFileHandle( FileStream?fileStream, bool ownsFileStream, HandleInheritability inheritability, MemoryMappedFileAccess access, MemoryMappedFileOptions options, long capacity) : base(ownsHandle: true) { Debug.Assert(!ownsFileStream || fileStream != null, "We can only own a FileStream we're actually given."); // Store the arguments. We'll actually open the map when the view is created. _fileStream = fileStream; _ownsFileStream = ownsFileStream; _inheritability = inheritability; _access = access; _options = options; _capacity = capacity; IntPtr handlePtr; if (fileStream != null) { bool ignored = false; SafeFileHandle handle = fileStream.SafeFileHandle; handle.DangerousAddRef(ref ignored); _fileStreamHandle = handle; handlePtr = handle.DangerousGetHandle(); } else { handlePtr = IntPtr.MaxValue; } SetHandle(handlePtr); }
public async ValueTask RunAsync([Option("storage", new char[] { 's' })] string storageDirectoryPath, [Option("listen", new char[] { 'l' })] string listenAddress, [Option("verbose", new char[] { 'v' })] bool verbose = false) { try { DirectoryHelper.CreateDirectory(storageDirectoryPath); SetLogsDirectory(Path.Combine(storageDirectoryPath, "logs")); if (verbose) { ChangeLogLevel(NLog.LogLevel.Trace); } _lockFileStream = new FileStream(Path.Combine(storageDirectoryPath, "lock"), FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, 1, FileOptions.DeleteOnClose); _logger.Info("Starting..."); _logger.Info("AssemblyInformationalVersion: {0}", Assembly.GetExecutingAssembly().GetCustomAttribute <AssemblyInformationalVersionAttribute>()?.InformationalVersion); await Runner.EventLoopAsync(Path.Combine(storageDirectoryPath, "db"), OmniAddress.Parse(listenAddress), this.Context.CancellationToken); } catch (Exception e) { _logger.Error(e); } finally { _logger.Info("Stopping..."); NLog.LogManager.Shutdown(); _lockFileStream?.Dispose(); } }
private Result TryCreateLockFile() { void CreateLockFileStream() { lockStream = new FileStream(file, FileMode.Create, FileAccess.Write, FileShare.Read); lockStream.Write(BitConverter.GetBytes(CurrentProcessID), 0, sizeof(int)); lockStream.Flush(true); } try{ CreateLockFileStream(); return(Result.Success); }catch (DirectoryNotFoundException) { try{ CreateLockFileStream(); return(Result.Success); }catch { ReleaseLockFileStream(); return(Result.Fail); } }catch (IOException) { return(Result.HasProcess); }catch { ReleaseLockFileStream(); return(Result.Fail); } }
// </ThrowException> // <TestFinally> static void TestFinally() { FileStream?file = null; //Change the path to something that works on your machine. FileInfo fileInfo = new System.IO.FileInfo("./file.txt"); try { file = fileInfo.OpenWrite(); file.WriteByte(0xF); } finally { // Closing the file allows you to reopen it immediately - otherwise IOException is thrown. file?.Close(); } try { file = fileInfo.OpenWrite(); Console.WriteLine("OpenWrite() succeeded"); } catch (IOException) { Console.WriteLine("OpenWrite() failed"); } }
private void StartNewFile() { var now = DateTime.UtcNow; string path = Configuration.Path; string fileName; if (Configuration.SortByDate) { path = Path.Combine(path, "Log-" + now.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture)); string file = now.ToString("yyyy-MM-dd-HH-mm", CultureInfo.InvariantCulture); fileName = Path.Combine(path, "Nmea-" + file + ".txt"); } else { string file = now.ToString("yyyy-MM-dd-HH-mm", CultureInfo.InvariantCulture); fileName = Path.Combine(path, "Nmea-" + file + ".txt"); } if (_logFile != null && _textWriter != null) { _textWriter.Flush(); _textWriter.Close(); _logFile.Close(); _textWriter.Dispose(); _logFile.Dispose(); _textWriter = null; _logFile = null; } Directory.CreateDirectory(path); _logFile = new FileStream(fileName, FileMode.Append, FileAccess.Write); _textWriter = new StreamWriter(_logFile); }
internal XmlWriter CreateWriter(string outputFileName) { if (outputFileName == null) { throw new ArgumentNullException(nameof(outputFileName)); } // need to clone the settigns so that we can set CloseOutput to true to make sure the stream gets closed in the end XmlWriterSettings newSettings = this; if (!newSettings.CloseOutput) { newSettings = newSettings.Clone(); newSettings.CloseOutput = true; } FileStream?fs = null; try { // open file stream fs = new FileStream(outputFileName, FileMode.Create, FileAccess.Write, FileShare.Read, 0x1000, _useAsync); // create writer return(newSettings.CreateWriter(fs)); } catch { if (fs != null) { fs.Dispose(); } throw; } }
async Task ICrossProcessSemaphore.WaitAsync() { await LocalSemaphore.WaitAsync().ConfigureAwait(false); bool success = false; try { while (true) { try { lock (LocalSemaphore) { if (FileLock != null) { throw new ArgumentNullException(nameof(FileLock)); } EnsureFileExists(); FileLock = new FileStream(FilePath, FileMode.OpenOrCreate, FileAccess.Read, FileShare.None); success = true; return; } } catch (IOException) { await Task.Delay(SpinLockDelay).ConfigureAwait(false); } } } finally { if (!success) { LocalSemaphore.Release(); } } }
public TiffFileStreamContentSource(string fileName, bool preferAsync) { _fileName = fileName ?? throw new ArgumentNullException(nameof(fileName)); _preferAsync = preferAsync; _lock = new object(); _fileStream = GetOrCreateStream(preferAsync); }
internal static unsafe bool TryOpen(ReadOnlySpan <char> path, [NotNullWhen(true)] out FileStream?stream) { if (IsWindows) { var handle = CreateFile(path, ACCESS_MASK.GenericRight.GENERIC_READ, FileShare.FILE_SHARE_READ, null, CreationDisposition.OPEN_EXISTING, CreateFileFlags.FILE_ATTRIBUTE_NORMAL, SafeObjectHandle.Null); if (!handle.IsInvalid) { var fileHandle = new SafeFileHandle(handle.DangerousGetHandle(), ownsHandle: true); handle.SetHandleAsInvalid(); stream = new FileStream(fileHandle, System.IO.FileAccess.Read); return(true); } else { stream = null; return(false); } } else { // Make sure to trim the trailing \0 string fullPath = GetUtf16String(path.Slice(0, path.Length - 1)); if (!File.Exists(fullPath)) { stream = null; return(false); } stream = File.OpenRead(fullPath); return(true); } }
public DirSuperBackup(DirSuperBackupOptions?options = null) { try { this.Options = options ?? new DirSuperBackupOptions(); this.Lfs = new LargeFileSystem(new LargeFileSystemParams(this.Fs)); this.LfsUtf8 = new Utf8BomFileSystem(new Utf8BomFileSystemParam(this.Lfs)); if (Options.InfoLogFileName._IsFilled()) { InfoLogFileObj = this.LfsUtf8.OpenOrCreateAppend(Options.InfoLogFileName, flags: FileFlags.AutoCreateDirectory | FileFlags.BackupMode | FileFlags.LargeFs_AppendWithoutCrossBorder); InfoLogFileStream = InfoLogFileObj.GetStream(true); InfoLogWriter = new StreamWriter(InfoLogFileStream); } if (Options.ErrorLogFileName._IsFilled()) { ErrorLogFileObj = this.LfsUtf8.OpenOrCreateAppend(Options.ErrorLogFileName, flags: FileFlags.AutoCreateDirectory | FileFlags.BackupMode | FileFlags.LargeFs_AppendWithoutCrossBorder); ErrorLogFileStream = ErrorLogFileObj.GetStream(true); ErrorLogWriter = new StreamWriter(ErrorLogFileStream); } WriteLogAsync(DirSuperBackupLogType.Error, "------------------")._GetResult(); WriteLogAsync(DirSuperBackupLogType.Error, "Start")._GetResult(); } catch { this._DisposeSafe(); throw; } }
/// <summary>Returns the file stream appropriate for byte offset 'offset'</summary> public FileStream?FileStreamAtOffset(long offset) { var fidx = FileIndexAtOffset(offset); if (m_fs != null && fidx == m_fs_index) { return(m_fs); } if (m_fs != null) { m_fs.Dispose(); } m_fs_index = fidx; System.Diagnostics.Debug.Assert(m_fs_index >= -1 && m_fs_index <= Files.Count); if (m_fs_index < 0 || Files.Count == 0) { m_fs = null; } else if (m_fs_index >= Files.Count) { m_fs = new FileStream(Files[Files.Count - 1].FullName, FileMode.Open, FileAccess.Read, FileShare, FileBufferSize, FileOptions); m_fs.Position = m_fs.Length; } else { m_fs = new FileStream(Files[m_fs_index].FullName, FileMode.Open, FileAccess.Read, FileShare, FileBufferSize, FileOptions); Position = Position; } return(m_fs); }
internal void SetUnmanagedStructures(FileStream?fileStream, byte[]?preBuffer, byte[]?postBuffer, bool doDisconnect) { _fileStream = fileStream; _doDisconnect = doDisconnect; int buffsNumber = 0; if (preBuffer != null && preBuffer.Length > 0) { ++buffsNumber; } if (postBuffer != null && postBuffer.Length > 0) { ++buffsNumber; } object[]? objectsToPin = null; if (buffsNumber != 0) { objectsToPin = new object[buffsNumber]; if (preBuffer != null && preBuffer.Length > 0) { objectsToPin[--buffsNumber] = preBuffer; } if (postBuffer != null && postBuffer.Length > 0) { objectsToPin[--buffsNumber] = postBuffer; } } base.SetUnmanagedStructures(objectsToPin); }
/// <summary> /// Attempt to acquire the lock by opening the lock file with FileShare.None. Sets "Stream" /// and returns true if successful, returns false if the lock is already held by another /// thread or process. Guard must be held when calling this routine. /// </summary> internal bool TryLockFile() { Debug.Assert(Stream is null); FileStream?stream = null; try { stream = new FileStream(FilePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None); // On some targets, the file locking used to implement FileShare.None may not be // atomic with opening/creating the file. This creates a race window when another // thread holds the lock and is just about to unlock: we may be able to open the // file here, then the other thread unlocks and deletes the file, and then we // acquire the lock on our file handle - but the actual file is already deleted. // To close this race, we verify that the file does in fact still exist now that // we have successfully acquired the locked FileStream. (Note that this check is // safe because we cannot race with an other attempt to create the file since we // hold the guard, and after the FileStream constructor returned we can no race // with file deletion because we hold the lock.) if (!File.Exists(FilePath)) { // To simplify the logic, we treat this case as "unable to acquire the lock" // because it we caught another process while it owned the lock and was just // giving it up. If the caller retries, we'll likely acquire the lock then. stream.Dispose(); return(false); } } catch (Exception) { stream?.Dispose(); return(false); } Stream = stream; return(true); }
private int LoadTextureFromFile(string filePath) { FileStream?stream = File.OpenRead(filePath); using (Image <Rgba32> image = Image.Load <Rgba32>(stream)) { int width = image.Width; int height = image.Height; int[] data = new int[width * height]; // Just simple bit manipulation to convert RGBA to ABGR. for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { Rgba32 color = image[x, y]; data[(y * width) + x] = (color.A << 24) | (color.B << 16) | (color.G << 8) | (color.R << 0); } } GL.CreateTextures(TextureTarget.Texture2D, 1, out int result); GL.TextureStorage2D(result, 1, SizedInternalFormat.Rgba8, width, height); GL.TextureParameter(result, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear); GL.TextureParameter(result, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear); GL.TextureParameter(result, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat); GL.TextureParameter(result, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat); GL.TextureSubImage2D(result, 0, 0, 0, width, height, PixelFormat.Rgba, PixelType.UnsignedByte, data); return(result); } }
internal ResponseStreamAsyncResult(ResponseBody responseStream, FileStream fileStream, long offset, long count, bool chunked, CancellationToken cancellationToken) : this(responseStream, cancellationToken) { var boundHandle = responseStream.RequestContext.Server.RequestQueue.BoundHandle; _fileStream = fileStream; if (count == 0) { _dataChunks = null; _overlapped = new SafeNativeOverlapped(boundHandle, boundHandle.AllocateNativeOverlapped(IOCallback, this, null)); } else { _dataChunks = new HttpApiTypes.HTTP_DATA_CHUNK[chunked ? 3 : 1]; object[] objectsToPin = new object[_dataChunks.Length]; objectsToPin[_dataChunks.Length - 1] = _dataChunks; var chunkHeaderBuffer = new ArraySegment <byte>(); if (chunked) { chunkHeaderBuffer = Helpers.GetChunkHeader(count); _dataChunks[0].DataChunkType = HttpApiTypes.HTTP_DATA_CHUNK_TYPE.HttpDataChunkFromMemory; _dataChunks[0].fromMemory.BufferLength = (uint)chunkHeaderBuffer.Count; objectsToPin[0] = chunkHeaderBuffer.Array !; _dataChunks[1].DataChunkType = HttpApiTypes.HTTP_DATA_CHUNK_TYPE.HttpDataChunkFromFileHandle; _dataChunks[1].fromFile.offset = (ulong)offset; _dataChunks[1].fromFile.count = (ulong)count; _dataChunks[1].fromFile.fileHandle = _fileStream.SafeFileHandle.DangerousGetHandle(); // Nothing to pin for the file handle. _dataChunks[2].DataChunkType = HttpApiTypes.HTTP_DATA_CHUNK_TYPE.HttpDataChunkFromMemory; _dataChunks[2].fromMemory.BufferLength = (uint)Helpers.CRLF.Length; objectsToPin[1] = Helpers.CRLF; } else { _dataChunks[0].DataChunkType = HttpApiTypes.HTTP_DATA_CHUNK_TYPE.HttpDataChunkFromFileHandle; _dataChunks[0].fromFile.offset = (ulong)offset; _dataChunks[0].fromFile.count = (ulong)count; _dataChunks[0].fromFile.fileHandle = _fileStream.SafeFileHandle.DangerousGetHandle(); } // This call will pin needed memory _overlapped = new SafeNativeOverlapped(boundHandle, boundHandle.AllocateNativeOverlapped(IOCallback, this, objectsToPin)); if (chunked) { // These must be set after pinning with Overlapped. _dataChunks[0].fromMemory.pBuffer = Marshal.UnsafeAddrOfPinnedArrayElement(chunkHeaderBuffer.Array !, chunkHeaderBuffer.Offset); _dataChunks[2].fromMemory.pBuffer = Marshal.UnsafeAddrOfPinnedArrayElement(Helpers.CRLF, 0); } } }
public void Close() { m_stream?.Dispose(); m_stream = null; m_indexBlock = null; m_blockCache = null; }
/// <summary> /// Constructor /// </summary> public CsvWriter( string?fileName, CsvConfig csvConfig, int estimatedLineLenght, FileStream?existingFileStream = null, int flushDelay = 200) { if (!string.IsNullOrEmpty(fileName) && existingFileStream != null) { throw new Exception("CsvWriter constructor: There was neither an existingFileStream nor a fileName provided."); } if (existingFileStream != null) { FileName = existingFileStream.Name; } else { FileName = fileName !; } CsvConfig = csvConfig; if (csvConfig.Encoding != Encoding.UTF8) { throw new Exception($"CsvWriter constructor: Only reading from UTF8 files is supported, but the Encoding was " + $"{csvConfig.Encoding.EncodingName} for file {fileName}."); } delimiter = (byte)csvConfig.Delimiter; MaxLineByteLenght = CsvConfig.BufferSize / Csv.ByteBufferToReserveRatio; if (estimatedLineLenght * Csv.Utf8BytesPerChar > MaxLineByteLenght) { throw new Exception($"CsvWriter constructor: BufferSize {CsvConfig.BufferSize} should be at least " + $"{Csv.ByteBufferToReserveRatio*Csv.Utf8BytesPerChar} times bigger than the estimated length needed of " + $"{estimatedLineLenght} for file {fileName}."); } EstimatedLineLenght = estimatedLineLenght; tempChars = new char[50]; //tempChars is only used for formating decimals, which needs maybe 10-30 chars FlushDelay = flushDelay; if (existingFileStream is null) { isFileStreamOwner = true; //fileStream = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, CsvConfig.BufferSize, FileOptions.SequentialScan | FileOptions.WriteThrough); fileStream = new FileStream(fileName !, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None, CsvConfig.BufferSize); } else { isFileStreamOwner = false; fileStream = existingFileStream; } //byteArray = new byte[csvConfig.BufferSize]; //writePos = 0; //maxBufferWriteLength = CsvConfig.BufferSize - maxLineLenght; byteArray = new byte[csvConfig.BufferSize + MaxLineByteLenght]; writePos = 0; maxBufferWriteLength = CsvConfig.BufferSize; flushTimer = new Timer(flushTimerMethod, null, Timeout.Infinite, Timeout.Infinite); }
static void CreateFile(ref FileStream?stream, ref BinaryWriter?writer, string filename) { if (stream is not null || writer is not null) { throw new InvalidOperationException(); } stream = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.Read | FileShare.Delete); writer = new BinaryWriter(stream); }