Overwrite

Complete Overwrite of the Folder with the free shard. ServUO 57.3 has been added.

Server/Persistence/FileOperations.cs

@@ -0,0 +1,134 @@
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using Microsoft.Win32.SafeHandles;
+
+namespace Server
+{
+    public static class FileOperations
+    {
+        public const int KB = 1024;
+        public const int MB = 1024 * KB;
+
+        private const FileOptions NoBuffering = (FileOptions)0x20000000;
+
+        [DllImport("Kernel32", CharSet = CharSet.Auto, SetLastError = true)]
+        private static extern SafeFileHandle CreateFile(string lpFileName, int dwDesiredAccess, FileShare dwShareMode, IntPtr securityAttrs, FileMode dwCreationDisposition, int dwFlagsAndAttributes, IntPtr hTemplateFile);
+
+        private static int bufferSize = 1 * MB;
+        private static int concurrency = 1;
+
+        private static bool unbuffered = true;
+
+        public static int BufferSize
+        {
+            get
+            {
+                return bufferSize;
+            }
+            set
+            {
+                bufferSize = value;
+            }
+        }
+
+        public static int Concurrency
+        {
+            get
+            {
+                return concurrency;
+            }
+            set
+            {
+                concurrency = value;
+            }
+        }
+
+        public static bool Unbuffered
+        {
+            get
+            {
+                return unbuffered;
+            }
+            set
+            {
+                unbuffered = value;
+            }
+        }
+
+        public static bool AreSynchronous
+        {
+            get
+            {
+                return (concurrency < 1);
+            }
+        }
+
+        public static bool AreAsynchronous
+        {
+            get
+            {
+                return (concurrency > 0);
+            }
+        }
+
+        public static FileStream OpenSequentialStream(string path, FileMode mode, FileAccess access, FileShare share)
+        {
+            FileOptions options = FileOptions.SequentialScan;
+
+            if (concurrency > 0)
+            {
+                options |= FileOptions.Asynchronous;
+            }
+
+            if (unbuffered)
+            {
+                options |= NoBuffering;
+            }
+            else
+            {
+                return new FileStream(path, mode, access, share, bufferSize, options);
+            }
+
+            SafeFileHandle fileHandle = CreateFile(path, (int)access, share, IntPtr.Zero, mode, (int)options, IntPtr.Zero);
+
+            if (fileHandle.IsInvalid)
+            {
+                throw new IOException();
+            }
+
+            return new UnbufferedFileStream(fileHandle, access, bufferSize, (concurrency > 0));
+        }
+
+        private class UnbufferedFileStream : FileStream
+        {
+            private readonly SafeFileHandle fileHandle;
+
+            public UnbufferedFileStream(SafeFileHandle fileHandle, FileAccess access, int bufferSize, bool isAsync)
+                : base(fileHandle, access, bufferSize, isAsync)
+            {
+                this.fileHandle = fileHandle;
+            }
+
+            public override void Write(byte[] array, int offset, int count)
+            {
+                base.Write(array, offset, bufferSize);
+            }
+
+            public override IAsyncResult BeginWrite(byte[] array, int offset, int numBytes, AsyncCallback userCallback, object stateObject)
+            {
+                return base.BeginWrite(array, offset, bufferSize, userCallback, stateObject);
+            }
+
+            protected override void Dispose(bool disposing)
+            {
+                if (!this.fileHandle.IsClosed)
+                {
+                    this.fileHandle.Close();
+                }
+
+                base.Dispose(disposing);
+            }
+        }
+    }
+}