Switches to Kestrel (#102)

Projects/Server/Persistence/BinaryMemoryWriter.cs

@@ -25,7 +25,7 @@ namespace Server
   public sealed class BinaryMemoryWriter : BinaryFileWriter
   {
     private static byte[] indexBuffer;
-    private MemoryStream stream;
+    private readonly MemoryStream stream;
 
     public BinaryMemoryWriter()
       : base(new MemoryStream(512), true) =>

Projects/Server/Persistence/DynamicSaveStrategy.cs

@@ -29,16 +29,16 @@ namespace Server
 {
   public sealed class DynamicSaveStrategy : SaveStrategy
   {
-    private ConcurrentBag<Item> _decayBag;
+    private readonly ConcurrentBag<Item> _decayBag;
     private SequentialFileWriter _guildData, _guildIndex;
-    private BlockingCollection<QueuedMemoryWriter> _guildThreadWriters;
+    private readonly BlockingCollection<QueuedMemoryWriter> _guildThreadWriters;
 
     private SequentialFileWriter _itemData, _itemIndex;
 
-    private BlockingCollection<QueuedMemoryWriter> _itemThreadWriters;
+    private readonly BlockingCollection<QueuedMemoryWriter> _itemThreadWriters;
 
     private SequentialFileWriter _mobileData, _mobileIndex;
-    private BlockingCollection<QueuedMemoryWriter> _mobileThreadWriters;
+    private readonly BlockingCollection<QueuedMemoryWriter> _mobileThreadWriters;
 
     public DynamicSaveStrategy()
     {

Projects/Server/Persistence/FileOperations.cs

@@ -71,7 +71,7 @@ namespace Server
 #if !MONO
     private class UnbufferedFileStream : FileStream
     {
-      private SafeFileHandle fileHandle;
+      private readonly SafeFileHandle fileHandle;
 
       public UnbufferedFileStream(SafeFileHandle fileHandle, FileAccess access, int bufferSize, bool isAsync)
         : base(fileHandle, access, bufferSize, isAsync) =>

Projects/Server/Persistence/FileQueue.cs

@@ -29,19 +29,19 @@ namespace Server
 
   public sealed class FileQueue : IDisposable
   {
-    private static int bufferSize;
+    private static readonly int bufferSize;
 
-    private Chunk[] active;
+    private readonly Chunk[] active;
     private int activeCount;
     private Page buffered;
 
-    private FileCommitCallback callback;
+    private readonly FileCommitCallback callback;
 
     private ManualResetEvent idle;
 
-    private Queue<Page> pending;
+    private readonly Queue<Page> pending;
 
-    private object syncRoot;
+    private readonly object syncRoot;
 
     static FileQueue() => bufferSize = FileOperations.BufferSize;
 
@@ -193,8 +193,8 @@ namespace Server
     public sealed class Chunk
     {
       private int offset;
-      private FileQueue owner;
-      private int slot;
+      private readonly FileQueue owner;
+      private readonly int slot;
 
       public Chunk(FileQueue owner, int slot, byte[] buffer, int offset, int size)
       {

Projects/Server/Persistence/ParallelSaveStrategy.cs

@@ -28,7 +28,7 @@ namespace Server
 {
   public sealed class ParallelSaveStrategy : SaveStrategy
   {
-    private Queue<Item> _decayQueue;
+    private readonly Queue<Item> _decayQueue;
 
     private Consumer[] consumers;
     private int cycle;
@@ -40,7 +40,7 @@ namespace Server
 
     private SequentialFileWriter mobileData, mobileIndex;
 
-    private int processorCount;
+    private readonly int processorCount;
 
     public ParallelSaveStrategy(int processorCount)
     {
@@ -226,9 +226,9 @@ namespace Server
 
     private sealed class Producer : IEnumerable<ISerializable>
     {
-      private IEnumerable<BaseGuild> guilds;
-      private IEnumerable<Item> items;
-      private IEnumerable<Mobile> mobiles;
+      private readonly IEnumerable<BaseGuild> guilds;
+      private readonly IEnumerable<Item> items;
+      private readonly IEnumerable<Mobile> mobiles;
 
       public Producer()
       {
@@ -257,13 +257,13 @@ namespace Server
 
     private sealed class Consumer
     {
-      public ConsumableEntry[] buffer;
+      public readonly ConsumableEntry[] buffer;
 
-      public ManualResetEvent completionEvent;
+      public readonly ManualResetEvent completionEvent;
       public int head, done, tail;
-      private ParallelSaveStrategy owner;
+      private readonly ParallelSaveStrategy owner;
 
-      private Thread thread;
+      private readonly Thread thread;
 
       public Consumer(ParallelSaveStrategy owner, int bufferSize)
       {

Projects/Server/Persistence/QueuedMemoryWriter.cs

@@ -25,8 +25,8 @@ namespace Server
 {
   public sealed class QueuedMemoryWriter : BinaryFileWriter
   {
-    private MemoryStream _memStream;
-    private List<IndexInfo> _orderedIndexInfo = new List<IndexInfo>();
+    private readonly MemoryStream _memStream;
+    private readonly List<IndexInfo> _orderedIndexInfo = new List<IndexInfo>();
 
     public QueuedMemoryWriter()
       : base(new MemoryStream(1024 * 1024), true) =>

Projects/Server/Persistence/StandardSaveStrategy.cs

@@ -35,7 +35,7 @@ namespace Server
 
     public static SaveOption SaveType = SaveOption.Normal;
 
-    private Queue<Item> _decayQueue;
+    private readonly Queue<Item> _decayQueue;
 
     public StandardSaveStrategy() => _decayQueue = new Queue<Item>();