Sojaner.MemoryScanner/MemoryProviers/BaseMemoryProvider.cs

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;

namespace Sojaner.MemoryScanner.MemoryProviers
{
    #region public abstract class BaseMemoryProvider
    public abstract class BaseMemoryProvider :
        IPatchMemory,
        IReadMemory,
        IAcceptsProcess<Process>,
        IAcceptsPlugin<IConfigPlugin>,
        IMemoryReader,
        IMemoryWriter,
        IFileWriter,
        IDisposable
    {
        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; }


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

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