--- trunk/RomCheater/Serialization/SerializationReader.cs	2012/06/21 05:14:38	401
+++ trunk/RomCheater/Serialization/SerializationReader.cs	2013/06/02 19:21:16	445
@@ -2,10 +2,105 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using System.IO;
 
 namespace RomCheater.Serialization
 {
-    public class SerializationReader
+    public abstract class SerializationReader : ISerializationResultCount, IDisposable
     {
+         private static string CreateFilename(Guid guid)
+        {
+            if (guid == Guid.Empty)
+            {
+                return DEFAULT_PATH;
+            }
+            else
+            {
+                return string.Format(@"{0}\{1}", DEFAULT_FOLDER, string.Format("{0}.tmp", guid.ToString()));
+            }
+        }
+        private const string DEFAULT_FOLDER = "tmp";
+        private const string DEFAULT_FILENAME = "SerializedMemoryResults.tmp";
+        private static string DEFAULT_PATH = string.Format(@"{0}\{1}", DEFAULT_FOLDER, DEFAULT_FILENAME);
+        //public SerializationReader() : this(CreateFilename(Guid.Empty)) { CreateReader(Guid.Empty); }
+        public SerializationReader(Guid guid) : this(CreateFilename(guid)) { CreateReader(guid); } 
+        protected SerializationReader(string filename) { FileName = filename; }
+
+               
+
+        #region ISerializationResultCount members
+        public int ResultCount { get; protected set; }
+        #endregion
+        private FileStream fileStream;
+        protected BinaryReader binReader;
+        protected string FileName { get; private set; }
+        private void CreateReader(Guid guid)
+        {
+            fileStream = new FileStream(FileName, FileMode.Open, FileAccess.Read, FileShare.Read);
+            binReader = new BinaryReader(fileStream);
+        }
+            #region IDisposable Support
+        // Track whether Dispose has been called.
+        private bool disposed = false;
+        // Implement IDisposable.
+        // Do not make this method virtual.
+        // A derived class should not be able to override this method.
+        public void Dispose()
+        {
+            Dispose(true);
+            // This object will be cleaned up by the Dispose method.
+            // Therefore, you should call GC.SupressFinalize to
+            // take this object off the finalization queue
+            // and prevent finalization code for this object
+            // from executing a second time.
+            GC.SuppressFinalize(this);
+        }
+        // Dispose(bool disposing) executes in two distinct scenarios.
+        // If disposing equals true, the method has been called directly
+        // or indirectly by a user's code. Managed and unmanaged resources
+        // can be disposed.
+        // If disposing equals false, the method has been called by the
+        // runtime from inside the finalizer and you should not reference
+        // other objects. Only unmanaged resources can be disposed.
+        protected virtual void Dispose(bool disposing)
+        {
+            // Check to see if Dispose has already been called.
+            if (!this.disposed)
+            {
+                // If disposing equals true, dispose all managed
+                // and unmanaged resources.
+                if (disposing)
+                {
+                    // Dispose managed resources.
+                    //component.Dispose();
+                }
+
+                // Call the appropriate methods to clean up
+                // unmanaged resources here.
+                // If disposing is false,
+                // only the following code is executed.
+               
+                // clean up any resources
+                binReader.Close();
+                binReader = null;
+                fileStream = null;                
+                // Note disposing has been done.
+                disposed = true;
+
+            }
+        }
+        // Use C# destructor syntax for finalization code.
+        // This destructor will run only if the Dispose method
+        // does not get called.
+        // It gives your base class the opportunity to finalize.
+        // Do not provide destructors in types derived from this class.
+        ~SerializationReader()
+        {
+            // Do not re-create Dispose clean-up code here.
+            // Calling Dispose(false) is optimal in terms of
+            // readability and maintainability.
+            Dispose(false);
+        }
+        #endregion
     }
 }