Sojaner.MemoryScanner/MemoryProviers/BaseMemoryProvider.cs

#region Logging Defines
// include this any class or method that required logging, and comment-out what is not needed

#region Enabled logging levels
#define LOGGING_ENABLE_INFO
#define LOGGING_ENABLE_WARN
#define LOGGING_ENABLE_DEBUG
#define LOGGING_ENABLE_VERBOSEDEBUG
#define LOGGING_ENABLE_ERROR
#define LOGGING_ENABLE_VERBOSEERROR
#define LOGGING_ENABLE_PROFILER
#endregion
#endregion
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using RomCheater.Logging;
using System.Diagnostics;
using RomCheater.PluginFramework.Interfaces;
using System.IO;
using RomCheater.PluginFramework.Events;

namespace Sojaner.MemoryScanner.MemoryProviers
{
    #region public abstract class BaseMemoryProvider
    public abstract class BaseMemoryProvider :
        IPatchMemory,
        IReadMemory,
        IAcceptsProcess<Process>,
        IAcceptsPlugin<IConfigPlugin>,
        IMemoryReader,
        IMemoryWriter,
        IFileWriter,
        IDisposable,
        IAcceptsBytesReadEvent
    {
        private ProcessMemoryReader provider;
        public BaseMemoryProvider() { this.AcceptedPlugin = null; this.AcceptedProcess = null; isClosed = true; isOpen = false; }
        public BaseMemoryProvider(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }
        public BaseMemoryProvider(IConfigPlugin config, Process process) : this() { this.AcceptedPlugin = config; this.AcceptedProcess = process; }
        public BaseMemoryProvider(IAcceptsProcessAndConfig pconfig) : this() { this.AcceptedPlugin = pconfig.AcceptedPlugin; this.AcceptedProcess = pconfig.AcceptedProcess; }


        public event BaseEventHandler<OnBytesReadEventArgs> OnBytesRead;

        private bool isOpen { get; set; }
        private bool isClosed { get; set; }

        private void provider_OnBytesRead(OnBytesReadEventArgs e)
        {
            e.Sender = this;
            if (this.OnBytesRead != null)
                this.OnBytesRead.Invoke(e);
        }
        #region Open/Close Provider
        #region public virtual void OpenProvider()
        public virtual void OpenProvider()
        {
            if (isOpen)
            {
                logger.Warn.WriteLine("Provider has already been opened.");
                return;
            }
            try
            {
                provider = new ProcessMemoryReader();
                provider.ReadProcess = this.AcceptedProcess;
                //provider.OnBytesRead += new BaseEventHandler<OnBytesReadEventArgs>(provider_OnBytesRead);
                if (provider.ReadProcess == null) { logger.Error.WriteLine("{0}.OpenProvider() Could not attach to process: {1}", "", this.GetType().Name, this.AcceptedProcess.ToString()); return; }
                //provider.OpenProcess();
                isOpen = true;
                isClosed = false;
            }
            catch (Exception ex)
            {
                logger.Error.WriteLine("Failed to open provider: {0}{1}", System.Environment.NewLine, ex.ToString());
                isOpen = false;
                isClosed = true;
            }
        }
        #endregion
        #region public virtual void CloseProvider()
        public virtual void CloseProvider()
        {
            if (isClosed)
            {
                logger.Warn.WriteLine("Provider has already been closed.");
                return;
            }
            if (!isOpen)
            {
                logger.Warn.WriteLine("Provider cannot be closed, it was never opened...attempting to open provider.");
                OpenProvider();
                if (!isOpen)
                {
                    logger.Warn.WriteLine("Could not open provider");
                    return;
                }
            }
            try
            {
                //logger.VerboseDebug.WriteLine("CloseProvider(): System.Environment.StackTrace: {0}{1}", System.Environment.NewLine, System.Environment.StackTrace);
                if (provider == null) return;
                //provider.CloseHandle();
                provider = null; // free any memory associated with the provider
                isClosed = true;
                isOpen = false;
            }
            catch (Exception ex)
            {
                logger.Error.WriteLine("Failed to close provider: {0}{1}", System.Environment.NewLine, ex.ToString());
                isClosed = false;
                if (isOpen)
                {
                    throw new Exception("Provider is failed to close and still open.");
                }
            }
        }
        #endregion
        #endregion

        #region  IAcceptsProcess<Process> Members
        public Process AcceptedProcess { get; set; }
        #endregion
        #region IAcceptsPlugin<IConfigPlugin> Members
        public IConfigPlugin AcceptedPlugin { get; set; }
        #endregion
        #region EnsureProviderIsOpen methods : log and/or throw errors
        private bool EnsureProviderIsOpen() { return EnsureProviderIsOpenOrThrowError(); }
        private bool EnsureProviderIsOpenOrLogError() { return EnsureProviderIsOpenOrThrowOrLogError(false, true); }
        private bool EnsureProviderIsOpenOrThrowError() { return EnsureProviderIsOpenOrThrowOrLogError(true, true); }
        private bool EnsureProviderIsOpenOrThrowOrLogError(bool ThrowError, bool LogError)
        {
            if (!isOpen)
            {
                try { throw new Exception("Memory operation could not be completed because the provider is not open"); }
                catch (Exception ex)
                {
                    if (LogError)
                        logger.Error.WriteLine(ex.ToString());
                    if (ThrowError)
                        throw ex;
                    return false;
                }
            }
            return true;
        }
        #endregion

        #region IPatchMemory members
        #region public virtual bool PatchMemory(uint address, byte value)
        public virtual bool PatchMemory(uint address, byte value)
        {
            if (!EnsureProviderIsOpen()) { return false; }
            return provider.PatchMemory(address, value);
        }
        #endregion
        #region public virtual bool PatchMemory(uint address, sbyte value)
        public virtual bool PatchMemory(uint address, sbyte value)
        {
            if (!EnsureProviderIsOpen()) { return false; }
            return provider.PatchMemory(address, value);
        }
        #endregion
        #region public virtual bool PatchMemory(uint address, ushort value)
        public virtual bool PatchMemory(uint address, ushort value)
        {
            if (!EnsureProviderIsOpen()) { return false; }
            return provider.PatchMemory(address, value);
        }
        #endregion
        #region public virtual bool PatchMemory(uint address, short value)
        public virtual bool PatchMemory(uint address, short value)
        {
            if (!EnsureProviderIsOpen()) { return false; }
            return provider.PatchMemory(address, value);
        }
        #endregion
        #region public virtual bool PatchMemory(uint address, uint value)
        public virtual bool PatchMemory(uint address, uint value)
        {
            if (!EnsureProviderIsOpen()) { return false; }
            return provider.PatchMemory(address, value);
        }
        #endregion
        #region public virtual bool PatchMemory(uint address, int value)
        public virtual bool PatchMemory(uint address, int value)
        {
            if (!EnsureProviderIsOpen()) { return false; }
            return provider.PatchMemory(address, value);
        }
        #endregion
        #region public virtual bool PatchMemory(uint address, ulong value)
        public virtual bool PatchMemory(uint address, ulong value)
        {
            if (!EnsureProviderIsOpen()) { return false; }
            return provider.PatchMemory(address, value);
        }
        #endregion
        #region public virtual bool PatchMemory(uint address, long value)
        public virtual bool PatchMemory(uint address, long value)
        {
            if (!EnsureProviderIsOpen()) { return false; }
            return provider.PatchMemory(address, value);
        }
        #endregion
        #endregion

        #region IReadMemory members
        #region public virtual bool ReadMemory(uint address, out byte value)
        public virtual bool ReadMemory(uint address, out byte value)
        {
            value = 0;
            if (!EnsureProviderIsOpen()) { return false; }
            return provider.ReadMemory(address, out value);
        }
        #endregion
        #region public virtual bool ReadMemory(uint address, out sbyte value)
        public virtual bool ReadMemory(uint address, out sbyte value)
        {
            value = 0;
            if (!EnsureProviderIsOpen()) { return false; }
            return provider.ReadMemory(address, out value);
        }
        #endregion
        #region public virtual bool ReadMemory(uint address, out ushort value)
        public virtual bool ReadMemory(uint address, out ushort value)
        {
            value = 0;
            if (!EnsureProviderIsOpen()) { return false; }
            return provider.ReadMemory(address, out value);
        }
        #endregion
        #region public virtual bool ReadMemory(uint address, out short value)
        public virtual bool ReadMemory(uint address, out short value)
        {
            value = 0;
            if (!EnsureProviderIsOpen()) { return false; }
            return provider.ReadMemory(address, out value);
        }
        #endregion
        #region public virtual bool ReadMemory(uint address, out uint value)
        public virtual bool ReadMemory(uint address, out uint value)
        {
            value = 0;
            if (!EnsureProviderIsOpen()) { return false; }
            return provider.ReadMemory(address, out value);
        }
        #endregion
        #region public virtual bool ReadMemory(uint address, out int value)
        public virtual bool ReadMemory(uint address, out int value)
        {
            value = 0;
            if (!EnsureProviderIsOpen()) { return false; }
            return provider.ReadMemory(address, out value);
        }
        #endregion
        #region public virtual bool ReadMemory(uint address, out ulong value)
        public virtual bool ReadMemory(uint address, out ulong value)
        {
            value = 0;
            if (!EnsureProviderIsOpen()) { return false; }
            return provider.ReadMemory(address, out value);
        }
        #endregion
        #region public virtual bool ReadMemory(uint address, out long value)
        public virtual bool ReadMemory(uint address, out long value)
        {
            value = 0;
            if (!EnsureProviderIsOpen()) { return false; }
            return provider.ReadMemory(address, out value);
        }
        #endregion
        #endregion

        #region IMemoryReader members
        #region public virtual bool ReadFirstNonZeroByte(int MemoryAddress, uint bytesToRead, out int address)
        public virtual bool ReadFirstNonZeroByte(int MemoryAddress, uint bytesToRead, out int address)
        {
            address = 0;
            if (!EnsureProviderIsOpen()) { return false; }
            try { provider.ReadFirstNonZeroByte(MemoryAddress, bytesToRead, out address); return true; }
            catch { address = 0x00; return false; }
        }
        #endregion
        #region public virtual void ReadProcessMemoryAtOnce(int MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
        public virtual void ReadProcessMemoryAtOnce(uint MemoryAddress, uint bytesToRead, object UserState)
        {
            if (!EnsureProviderIsOpen()) { return; }
            try { provider.ReadProcessMemoryAtOnce(MemoryAddress, bytesToRead, UserState); }
            catch { }
        }
        public virtual void ReadProcessMemoryAtOnce(uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
        {
            bytesRead = 0x00;
            data = new byte[bytesToRead];
            if (!EnsureProviderIsOpen()) { return; }
            try { provider.ReadProcessMemoryAtOnce(MemoryAddress, bytesToRead, out bytesRead, out data); }
            catch { bytesRead = 0x00; data = new byte[] { }; }
        }
        #endregion
        #region public virtual void ReadProcessMemory(int MemoryAddress, int bytesToRead, out int bytesRead, out byte[] data)
        public virtual void ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
        {
            bytesRead = 0x00;
            data = new byte[bytesToRead];
            if (!EnsureProviderIsOpen()) { return; }
            try { provider.ReadProcessMemory(MemoryAddress, bytesToRead, out bytesRead, out data); }
            catch { bytesRead = 0x00; data = new byte[] { }; }
        }
        public virtual void ReadProcessMemory(int MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
        {
            bytesRead = 0x00;
            data = new byte[bytesToRead];
            if (!EnsureProviderIsOpen()) { return; }
            try { provider.ReadProcessMemory(MemoryAddress, bytesToRead, out bytesRead, out data); }
            catch { bytesRead = 0x00; data = new byte[] { }; }
        }
        #endregion
        #region IMemoryWriter members
        //#region public virtual void WriteProcessMemory(int MemoryAddress, byte byteToWrite, out int bytesWritten)
        //public virtual void WriteProcessMemory(int MemoryAddress, byte byteToWrite, out int bytesWritten)
        //{
        //    bytesWritten = 0;
        //    if (!EnsureProviderIsOpen()) { return; }
        //    try { provider.WriteProcessMemory(MemoryAddress, new byte[] { byteToWrite }, out bytesWritten); }
        //    catch { bytesWritten = 0x00; }
        //}
        //#endregion
        #region public virtual void WriteProcessMemory(int MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
        public virtual void WriteProcessMemory(int MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
        {
            bytesWritten = 0;
            if (!EnsureProviderIsOpen()) { return; }
            try { provider.WriteProcessMemory(MemoryAddress, bytesToWrite, out bytesWritten); }
            catch { bytesWritten = 0x00; }
        }
        public virtual void WriteProcessMemory(uint MemoryAddress, byte[] bytesToWrite, out uint bytesWritten)
        {
            bytesWritten = 0;
            if (!EnsureProviderIsOpen()) { return; }
            try { provider.WriteProcessMemory(MemoryAddress, bytesToWrite, out bytesWritten); }
            catch { bytesWritten = 0x00; }
        }
        #endregion
        #endregion
        #endregion
        #region IFileWriter members
        #region  public virtual bool WriteProcessMemoryToFile(string filename, int MemoryAddress, uint bytesToRead, out int bytesRead)
        public virtual bool WriteProcessMemoryToFile(string filename, int MemoryAddress, uint bytesToRead, out int bytesRead)
        {
            bytesRead = 0;
            if (!EnsureProviderIsOpen()) { return false; }
            try { provider.WriteProcessMemoryToFile(filename, MemoryAddress, bytesToRead, out bytesRead); return true; }
            catch
            { bytesRead = 0x00; return false; }
        }
        #endregion
        #endregion

        #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.
                if (!isClosed)
                    CloseProvider();
                // 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.
        ~BaseMemoryProvider()
        {
            // Do not re-create Dispose clean-up code here.
            // Calling Dispose(false) is optimal in terms of
            // readability and maintainability.
            Dispose(false);
        }
        #endregion
    }
    #endregion
}
Revision:	428
Committed:	Tue May 28 13:32:28 2013 UTC (10 years, 6 months ago) by william
File size:	18426 byte(s)
Log Message:	+ fix memory scanner and memory providers to read and write process memory simulataneously without crashing due to null process handle * this has been done using ProcessMemoryChunk for all memory read/write operations we no longer need to open and close native handles to the process
#	Content
1	#region Logging Defines
2	// include this any class or method that required logging, and comment-out what is not needed
3
4	#region Enabled logging levels
5	#define LOGGING_ENABLE_INFO
6	#define LOGGING_ENABLE_WARN
7	#define LOGGING_ENABLE_DEBUG
8	#define LOGGING_ENABLE_VERBOSEDEBUG
9	#define LOGGING_ENABLE_ERROR
10	#define LOGGING_ENABLE_VERBOSEERROR
11	#define LOGGING_ENABLE_PROFILER
12	#endregion
13	#endregion
14	using System;
15	using System.Collections.Generic;
16	using System.Linq;
17	using System.Text;
18	using RomCheater.Logging;
19	using System.Diagnostics;
20	using RomCheater.PluginFramework.Interfaces;
21	using System.IO;
22	using RomCheater.PluginFramework.Events;
23
24	namespace Sojaner.MemoryScanner.MemoryProviers
25	{
26	#region public abstract class BaseMemoryProvider
27	public abstract class BaseMemoryProvider :
28	IPatchMemory,
29	IReadMemory,
30	IAcceptsProcess<Process>,
31	IAcceptsPlugin<IConfigPlugin>,
32	IMemoryReader,
33	IMemoryWriter,
34	IFileWriter,
35	IDisposable,
36	IAcceptsBytesReadEvent
37	{
38	private ProcessMemoryReader provider;
39	public BaseMemoryProvider() { this.AcceptedPlugin = null; this.AcceptedProcess = null; isClosed = true; isOpen = false; }
40	public BaseMemoryProvider(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }
41	public BaseMemoryProvider(IConfigPlugin config, Process process) : this() { this.AcceptedPlugin = config; this.AcceptedProcess = process; }
42	public BaseMemoryProvider(IAcceptsProcessAndConfig pconfig) : this() { this.AcceptedPlugin = pconfig.AcceptedPlugin; this.AcceptedProcess = pconfig.AcceptedProcess; }
43
44
45	public event BaseEventHandler<OnBytesReadEventArgs> OnBytesRead;
46
47	private bool isOpen { get; set; }
48	private bool isClosed { get; set; }
49
50	private void provider_OnBytesRead(OnBytesReadEventArgs e)
51	{
52	e.Sender = this;
53	if (this.OnBytesRead != null)
54	this.OnBytesRead.Invoke(e);
55	}
56	#region Open/Close Provider
57	#region public virtual void OpenProvider()
58	public virtual void OpenProvider()
59	{
60	if (isOpen)
61	{
62	logger.Warn.WriteLine("Provider has already been opened.");
63	return;
64	}
65	try
66	{
67	provider = new ProcessMemoryReader();
68	provider.ReadProcess = this.AcceptedProcess;
69	//provider.OnBytesRead += new BaseEventHandler<OnBytesReadEventArgs>(provider_OnBytesRead);
70	if (provider.ReadProcess == null) { logger.Error.WriteLine("{0}.OpenProvider() Could not attach to process: {1}", "", this.GetType().Name, this.AcceptedProcess.ToString()); return; }
71	//provider.OpenProcess();
72	isOpen = true;
73	isClosed = false;
74	}
75	catch (Exception ex)
76	{
77	logger.Error.WriteLine("Failed to open provider: {0}{1}", System.Environment.NewLine, ex.ToString());
78	isOpen = false;
79	isClosed = true;
80	}
81	}
82	#endregion
83	#region public virtual void CloseProvider()
84	public virtual void CloseProvider()
85	{
86	if (isClosed)
87	{
88	logger.Warn.WriteLine("Provider has already been closed.");
89	return;
90	}
91	if (!isOpen)
92	{
93	logger.Warn.WriteLine("Provider cannot be closed, it was never opened...attempting to open provider.");
94	OpenProvider();
95	if (!isOpen)
96	{
97	logger.Warn.WriteLine("Could not open provider");
98	return;
99	}
100	}
101	try
102	{
103	//logger.VerboseDebug.WriteLine("CloseProvider(): System.Environment.StackTrace: {0}{1}", System.Environment.NewLine, System.Environment.StackTrace);
104	if (provider == null) return;
105	//provider.CloseHandle();
106	provider = null; // free any memory associated with the provider
107	isClosed = true;
108	isOpen = false;
109	}
110	catch (Exception ex)
111	{
112	logger.Error.WriteLine("Failed to close provider: {0}{1}", System.Environment.NewLine, ex.ToString());
113	isClosed = false;
114	if (isOpen)
115	{
116	throw new Exception("Provider is failed to close and still open.");
117	}
118	}
119	}
120	#endregion
121	#endregion
122
123	#region IAcceptsProcess<Process> Members
124	public Process AcceptedProcess { get; set; }
125	#endregion
126	#region IAcceptsPlugin<IConfigPlugin> Members
127	public IConfigPlugin AcceptedPlugin { get; set; }
128	#endregion
129	#region EnsureProviderIsOpen methods : log and/or throw errors
130	private bool EnsureProviderIsOpen() { return EnsureProviderIsOpenOrThrowError(); }
131	private bool EnsureProviderIsOpenOrLogError() { return EnsureProviderIsOpenOrThrowOrLogError(false, true); }
132	private bool EnsureProviderIsOpenOrThrowError() { return EnsureProviderIsOpenOrThrowOrLogError(true, true); }
133	private bool EnsureProviderIsOpenOrThrowOrLogError(bool ThrowError, bool LogError)
134	{
135	if (!isOpen)
136	{
137	try { throw new Exception("Memory operation could not be completed because the provider is not open"); }
138	catch (Exception ex)
139	{
140	if (LogError)
141	logger.Error.WriteLine(ex.ToString());
142	if (ThrowError)
143	throw ex;
144	return false;
145	}
146	}
147	return true;
148	}
149	#endregion
150
151	#region IPatchMemory members
152	#region public virtual bool PatchMemory(uint address, byte value)
153	public virtual bool PatchMemory(uint address, byte value)
154	{
155	if (!EnsureProviderIsOpen()) { return false; }
156	return provider.PatchMemory(address, value);
157	}
158	#endregion
159	#region public virtual bool PatchMemory(uint address, sbyte value)
160	public virtual bool PatchMemory(uint address, sbyte value)
161	{
162	if (!EnsureProviderIsOpen()) { return false; }
163	return provider.PatchMemory(address, value);
164	}
165	#endregion
166	#region public virtual bool PatchMemory(uint address, ushort value)
167	public virtual bool PatchMemory(uint address, ushort value)
168	{
169	if (!EnsureProviderIsOpen()) { return false; }
170	return provider.PatchMemory(address, value);
171	}
172	#endregion
173	#region public virtual bool PatchMemory(uint address, short value)
174	public virtual bool PatchMemory(uint address, short value)
175	{
176	if (!EnsureProviderIsOpen()) { return false; }
177	return provider.PatchMemory(address, value);
178	}
179	#endregion
180	#region public virtual bool PatchMemory(uint address, uint value)
181	public virtual bool PatchMemory(uint address, uint value)
182	{
183	if (!EnsureProviderIsOpen()) { return false; }
184	return provider.PatchMemory(address, value);
185	}
186	#endregion
187	#region public virtual bool PatchMemory(uint address, int value)
188	public virtual bool PatchMemory(uint address, int value)
189	{
190	if (!EnsureProviderIsOpen()) { return false; }
191	return provider.PatchMemory(address, value);
192	}
193	#endregion
194	#region public virtual bool PatchMemory(uint address, ulong value)
195	public virtual bool PatchMemory(uint address, ulong value)
196	{
197	if (!EnsureProviderIsOpen()) { return false; }
198	return provider.PatchMemory(address, value);
199	}
200	#endregion
201	#region public virtual bool PatchMemory(uint address, long value)
202	public virtual bool PatchMemory(uint address, long value)
203	{
204	if (!EnsureProviderIsOpen()) { return false; }
205	return provider.PatchMemory(address, value);
206	}
207	#endregion
208	#endregion
209
210	#region IReadMemory members
211	#region public virtual bool ReadMemory(uint address, out byte value)
212	public virtual bool ReadMemory(uint address, out byte value)
213	{
214	value = 0;
215	if (!EnsureProviderIsOpen()) { return false; }
216	return provider.ReadMemory(address, out value);
217	}
218	#endregion
219	#region public virtual bool ReadMemory(uint address, out sbyte value)
220	public virtual bool ReadMemory(uint address, out sbyte value)
221	{
222	value = 0;
223	if (!EnsureProviderIsOpen()) { return false; }
224	return provider.ReadMemory(address, out value);
225	}
226	#endregion
227	#region public virtual bool ReadMemory(uint address, out ushort value)
228	public virtual bool ReadMemory(uint address, out ushort value)
229	{
230	value = 0;
231	if (!EnsureProviderIsOpen()) { return false; }
232	return provider.ReadMemory(address, out value);
233	}
234	#endregion
235	#region public virtual bool ReadMemory(uint address, out short value)
236	public virtual bool ReadMemory(uint address, out short value)
237	{
238	value = 0;
239	if (!EnsureProviderIsOpen()) { return false; }
240	return provider.ReadMemory(address, out value);
241	}
242	#endregion
243	#region public virtual bool ReadMemory(uint address, out uint value)
244	public virtual bool ReadMemory(uint address, out uint value)
245	{
246	value = 0;
247	if (!EnsureProviderIsOpen()) { return false; }
248	return provider.ReadMemory(address, out value);
249	}
250	#endregion
251	#region public virtual bool ReadMemory(uint address, out int value)
252	public virtual bool ReadMemory(uint address, out int value)
253	{
254	value = 0;
255	if (!EnsureProviderIsOpen()) { return false; }
256	return provider.ReadMemory(address, out value);
257	}
258	#endregion
259	#region public virtual bool ReadMemory(uint address, out ulong value)
260	public virtual bool ReadMemory(uint address, out ulong value)
261	{
262	value = 0;
263	if (!EnsureProviderIsOpen()) { return false; }
264	return provider.ReadMemory(address, out value);
265	}
266	#endregion
267	#region public virtual bool ReadMemory(uint address, out long value)
268	public virtual bool ReadMemory(uint address, out long value)
269	{
270	value = 0;
271	if (!EnsureProviderIsOpen()) { return false; }
272	return provider.ReadMemory(address, out value);
273	}
274	#endregion
275	#endregion
276
277	#region IMemoryReader members
278	#region public virtual bool ReadFirstNonZeroByte(int MemoryAddress, uint bytesToRead, out int address)
279	public virtual bool ReadFirstNonZeroByte(int MemoryAddress, uint bytesToRead, out int address)
280	{
281	address = 0;
282	if (!EnsureProviderIsOpen()) { return false; }
283	try { provider.ReadFirstNonZeroByte(MemoryAddress, bytesToRead, out address); return true; }
284	catch { address = 0x00; return false; }
285	}
286	#endregion
287	#region public virtual void ReadProcessMemoryAtOnce(int MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
288	public virtual void ReadProcessMemoryAtOnce(uint MemoryAddress, uint bytesToRead, object UserState)
289	{
290	if (!EnsureProviderIsOpen()) { return; }
291	try { provider.ReadProcessMemoryAtOnce(MemoryAddress, bytesToRead, UserState); }
292	catch { }
293	}
294	public virtual void ReadProcessMemoryAtOnce(uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
295	{
296	bytesRead = 0x00;
297	data = new byte[bytesToRead];
298	if (!EnsureProviderIsOpen()) { return; }
299	try { provider.ReadProcessMemoryAtOnce(MemoryAddress, bytesToRead, out bytesRead, out data); }
300	catch { bytesRead = 0x00; data = new byte[] { }; }
301	}
302	#endregion
303	#region public virtual void ReadProcessMemory(int MemoryAddress, int bytesToRead, out int bytesRead, out byte[] data)
304	public virtual void ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
305	{
306	bytesRead = 0x00;
307	data = new byte[bytesToRead];
308	if (!EnsureProviderIsOpen()) { return; }
309	try { provider.ReadProcessMemory(MemoryAddress, bytesToRead, out bytesRead, out data); }
310	catch { bytesRead = 0x00; data = new byte[] { }; }
311	}
312	public virtual void ReadProcessMemory(int MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
313	{
314	bytesRead = 0x00;
315	data = new byte[bytesToRead];
316	if (!EnsureProviderIsOpen()) { return; }
317	try { provider.ReadProcessMemory(MemoryAddress, bytesToRead, out bytesRead, out data); }
318	catch { bytesRead = 0x00; data = new byte[] { }; }
319	}
320	#endregion
321	#region IMemoryWriter members
322	//#region public virtual void WriteProcessMemory(int MemoryAddress, byte byteToWrite, out int bytesWritten)
323	//public virtual void WriteProcessMemory(int MemoryAddress, byte byteToWrite, out int bytesWritten)
324	//{
325	// bytesWritten = 0;
326	// if (!EnsureProviderIsOpen()) { return; }
327	// try { provider.WriteProcessMemory(MemoryAddress, new byte[] { byteToWrite }, out bytesWritten); }
328	// catch { bytesWritten = 0x00; }
329	//}
330	//#endregion
331	#region public virtual void WriteProcessMemory(int MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
332	public virtual void WriteProcessMemory(int MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
333	{
334	bytesWritten = 0;
335	if (!EnsureProviderIsOpen()) { return; }
336	try { provider.WriteProcessMemory(MemoryAddress, bytesToWrite, out bytesWritten); }
337	catch { bytesWritten = 0x00; }
338	}
339	public virtual void WriteProcessMemory(uint MemoryAddress, byte[] bytesToWrite, out uint bytesWritten)
340	{
341	bytesWritten = 0;
342	if (!EnsureProviderIsOpen()) { return; }
343	try { provider.WriteProcessMemory(MemoryAddress, bytesToWrite, out bytesWritten); }
344	catch { bytesWritten = 0x00; }
345	}
346	#endregion
347	#endregion
348	#endregion
349	#region IFileWriter members
350	#region public virtual bool WriteProcessMemoryToFile(string filename, int MemoryAddress, uint bytesToRead, out int bytesRead)
351	public virtual bool WriteProcessMemoryToFile(string filename, int MemoryAddress, uint bytesToRead, out int bytesRead)
352	{
353	bytesRead = 0;
354	if (!EnsureProviderIsOpen()) { return false; }
355	try { provider.WriteProcessMemoryToFile(filename, MemoryAddress, bytesToRead, out bytesRead); return true; }
356	catch
357	{ bytesRead = 0x00; return false; }
358	}
359	#endregion
360	#endregion
361
362	#region IDisposable Support
363	// Track whether Dispose has been called.
364	private bool disposed = false;
365	// Implement IDisposable.
366	// Do not make this method virtual.
367	// A derived class should not be able to override this method.
368	public void Dispose()
369	{
370	Dispose(true);
371	// This object will be cleaned up by the Dispose method.
372	// Therefore, you should call GC.SupressFinalize to
373	// take this object off the finalization queue
374	// and prevent finalization code for this object
375	// from executing a second time.
376	GC.SuppressFinalize(this);
377	}
378	// Dispose(bool disposing) executes in two distinct scenarios.
379	// If disposing equals true, the method has been called directly
380	// or indirectly by a user's code. Managed and unmanaged resources
381	// can be disposed.
382	// If disposing equals false, the method has been called by the
383	// runtime from inside the finalizer and you should not reference
384	// other objects. Only unmanaged resources can be disposed.
385	protected virtual void Dispose(bool disposing)
386	{
387	// Check to see if Dispose has already been called.
388	if (!this.disposed)
389	{
390	// If disposing equals true, dispose all managed
391	// and unmanaged resources.
392	if (disposing)
393	{
394	// Dispose managed resources.
395	//component.Dispose();
396	}
397
398	// Call the appropriate methods to clean up
399	// unmanaged resources here.
400	// If disposing is false,
401	// only the following code is executed.
402	if (!isClosed)
403	CloseProvider();
404	// Note disposing has been done.
405	disposed = true;
406
407	}
408	}
409	// Use C# destructor syntax for finalization code.
410	// This destructor will run only if the Dispose method
411	// does not get called.
412	// It gives your base class the opportunity to finalize.
413	// Do not provide destructors in types derived from this class.
414	~BaseMemoryProvider()
415	{
416	// Do not re-create Dispose clean-up code here.
417	// Calling Dispose(false) is optimal in terms of
418	// readability and maintainability.
419	Dispose(false);
420	}
421	#endregion
422	}
423	#endregion
424	}