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
{
    public abstract class BaseMemoryProvider :
        IPatchMemory, 
        IReadMemory, 
        IAcceptsProcess<Process>,
        IAcceptsPlugin<IConfigPlugin>,
        IMemoryReader,
        IMemoryWriter,
        IFileWriter
    {
        private ProcessMemoryReader provider;
        public BaseMemoryProvider() { this.AcceptedPlugin = null; this.AcceptedProcess = null; }
        public BaseMemoryProvider(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }
        public BaseMemoryProvider(IConfigPlugin config, Process process) : this() { this.AcceptedPlugin = config; this.AcceptedProcess = process; }
        public BaseMemoryProvider(IAcceptsProcessAndConfig config) : this() { this.AcceptedPlugin = config.AcceptedPlugin; this.AcceptedProcess = config.AcceptedProcess; }

        protected virtual void OpenProvider()
        {
            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();
        }
        protected virtual void CloseProvider()
        {
            if (provider == null) return;
            provider.CloseHandle();
            provider = null; // free any memory associated with the provider
        }
        #region  IAcceptsProcess<Process> Members
        public Process AcceptedProcess { get; set; }
        #endregion
        #region IAcceptsPlugin<IConfigPlugin> Members
        public IConfigPlugin AcceptedPlugin { get; set; }
        #endregion
        #region IPatchMemory members
        #region public virtual bool PatchMemory(uint address, byte value)
        public virtual bool PatchMemory(uint address, byte value)
        {
            OpenProvider();
            int bytesWritten;
            byte[] bitData = BitConverter.GetBytes(value);
            provider.WriteProcessMemory(address, bitData, out bytesWritten);
            CloseProvider();
            byte check = 0;
            ReadMemory(address, out check);
            if (check == value) return true;
            return false;
        }
        #endregion
        #region public virtual bool PatchMemory(uint address, sbyte value)
        public virtual bool PatchMemory(uint address, sbyte value)
        {
            OpenProvider();
            int bytesWritten;
            byte[] bitData = BitConverter.GetBytes(value);
            provider.WriteProcessMemory(address, bitData, out bytesWritten);
            CloseProvider();
            sbyte check = 0;
            ReadMemory(address, out check);
            if (check == value) return true;
            return false;
        }
        #endregion
        #region public virtual bool PatchMemory(uint address, ushort value)
        public virtual bool PatchMemory(uint address, ushort value)
        {
            OpenProvider();
            int bytesWritten;
            byte[] bitData = BitConverter.GetBytes(value);
            provider.WriteProcessMemory(address, bitData, out bytesWritten);
            CloseProvider();
            ushort check = 0;
            ReadMemory(address, out check);
            if (check == value) return true;
            return false;
        }
        #endregion
        #region public virtual bool PatchMemory(uint address, short value)
        public virtual bool PatchMemory(uint address, short value)
        {
            OpenProvider();
            int bytesWritten;
            byte[] bitData = BitConverter.GetBytes(value);
            provider.WriteProcessMemory(address, bitData, out bytesWritten);
            CloseProvider();
            short check = 0;
            ReadMemory(address, out check);
            if (check == value) return true;
            return false;
        }
        #endregion
        #region public virtual bool PatchMemory(uint address, uint value)
        public virtual bool PatchMemory(uint address, uint value)
        {
            OpenProvider();
            int bytesWritten;
            byte[] bitData = BitConverter.GetBytes(value);
            provider.WriteProcessMemory(address, bitData, out bytesWritten);
            CloseProvider();
            uint check = 0;
            ReadMemory(address, out check);
            if (check == value) return true;
            return false;
        }
        #endregion
        #region public virtual bool PatchMemory(uint address, int value)
        public virtual bool PatchMemory(uint address, int value)
        {
            OpenProvider();
            int bytesWritten;
            byte[] bitData = BitConverter.GetBytes(value);
            provider.WriteProcessMemory(address, bitData, out bytesWritten);
            CloseProvider();
            int check = 0;
            ReadMemory(address, out check);
            if (check == value) return true;
            return false;
        }
        #endregion
        #region public virtual bool PatchMemory(uint address, ulong value)
        public virtual bool PatchMemory(uint address, ulong value)
        {
            OpenProvider();
            int bytesWritten;
            byte[] bitData = BitConverter.GetBytes(value);
            provider.WriteProcessMemory(address, bitData, out bytesWritten);
            CloseProvider();
            ulong check = 0;
            ReadMemory(address, out check);
            if (check == value) return true;
            return false;
        }
        #endregion
        #region public virtual bool PatchMemory(uint address, long value)
        public virtual bool PatchMemory(uint address, long value)
        {
            OpenProvider();
            int bytesWritten;
            byte[] bitData = BitConverter.GetBytes(value);
            provider.WriteProcessMemory(address, bitData, out bytesWritten);
            CloseProvider();
            long check = 0;
            ReadMemory(address, out check);
            if (check == value) return true;
            return false;
        }
        #endregion
        #endregion

        #region IReadMemory members
        #region public virtual bool ReadMemory(uint address, out byte value)
        public virtual bool ReadMemory(uint address, out byte value)
        {
            try
            {
                value = 0;
                OpenProvider();
                int bytesReadSize;
                byte[] bitData;
                provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
                value = bitData[0];
                CloseProvider();
                return true;
            }
            catch
            {
                value = 0x00;
                return false;
            }
        }
        #endregion
        #region public virtual bool ReadMemory(uint address, out sbyte value)
        public virtual bool ReadMemory(uint address, out sbyte value)
        {
            try
            {
                value = 0;
                OpenProvider();
                int bytesReadSize;
                byte[] bitData;
                provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
                value = Convert.ToSByte(bitData[0]);
                CloseProvider();
                return true;
            }
            catch
            {
                value = 0x00;
                return false;
            }
        }
        #endregion
        #region public virtual bool ReadMemory(uint address, out ushort value)
        public virtual bool ReadMemory(uint address, out ushort value)
        {
            try
            {
                value = 0;
                OpenProvider();
                int bytesReadSize;
                byte[] bitData;
                provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
                value = BitConverter.ToUInt16(bitData, 0);
                CloseProvider();
                return true;
            }
            catch
            {
                value = 0x00;
                return false;
            }
        }
        #endregion
        #region public virtual bool ReadMemory(uint address, out short value)
        public virtual bool ReadMemory(uint address, out short value)
        {
            try
            {
                value = 0;
                OpenProvider();
                int bytesReadSize;
                byte[] bitData;
                provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
                value = BitConverter.ToInt16(bitData, 0);
                CloseProvider();
                return true;
            }
            catch
            {
                value = 0x00;
                return false;
            }
        }
        #endregion
        #region public virtual bool ReadMemory(uint address, out uint value)
        public virtual bool ReadMemory(uint address, out uint value)
        {
            try
            {
                value = 0;
                OpenProvider();
                int bytesReadSize;
                byte[] bitData;
                provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
                value = BitConverter.ToUInt32(bitData, 0);
                CloseProvider();
                return true;
            }
            catch
            {
                value = 0x00;
                return false;
            }
        }
        #endregion
        #region public virtual bool ReadMemory(uint address, out int value)
        public virtual bool ReadMemory(uint address, out int value)
        {
            try
            {
                value = 0;
                OpenProvider();
                int bytesReadSize;
                byte[] bitData;
                provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
                value = BitConverter.ToInt32(bitData, 0);
                CloseProvider();
                return true;
            }
            catch
            {
                value = 0x00;
                return false;
            }
        }
        #endregion
        #region public virtual bool ReadMemory(uint address, out ulong value)
        public virtual bool ReadMemory(uint address, out ulong value)
        {
            try
            {
                value = 0;
                OpenProvider();
                int bytesReadSize;
                byte[] bitData;
                provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
                value = BitConverter.ToUInt64(bitData, 0);
                CloseProvider();
                return true;
            }
            catch
            {
                value = 0x00;
                return false;
            }
        }
        #endregion
        #region public virtual bool ReadMemory(uint address, out long value)
        public virtual bool ReadMemory(uint address, out long value)
        {
            try
            {
                value = 0;
                OpenProvider();
                int bytesReadSize;
                byte[] bitData;
                provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
                value = BitConverter.ToInt64(bitData, 0);
                CloseProvider();
                return true;
            }
            catch
            {
                value = 0x00;
                return false;
            }
        }
        #endregion
        #endregion

        #region IMemoryReader members
        #region public virtual bool ReadFirstNonZeroByte(uint MemoryAddress, uint bytesToRead, out uint address)
        public virtual bool ReadFirstNonZeroByte(uint MemoryAddress, uint bytesToRead, out uint address)
        {
            try
            {
                OpenProvider();
                provider.ReadFirstNonZeroByte(MemoryAddress, bytesToRead, out address);
                CloseProvider();
                return true;
            }
            catch
            {
                address = 0x00;
                return false;
            }
        }
        #endregion       
        #region public virtual void ReadProcessMemory(uint MemoryAddress, int bytesToRead, out int bytesRead, out byte[] data)
        public virtual void ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
        {
            try
            {
                OpenProvider();
                provider.ReadProcessMemory(MemoryAddress, bytesToRead, out bytesRead, out data);
                CloseProvider();
            }
            catch
            {
                bytesRead = 0x00;
                data = new byte[] { };
            }        
        }
        #endregion
        #region IMemoryWriter members
        #region public virtual void WriteProcessMemory(uint MemoryAddress, byte byteToWrite, out int bytesWritten)
        public virtual void WriteProcessMemory(uint MemoryAddress, byte byteToWrite, out int bytesWritten)
        {
            try
            {
                OpenProvider();
                provider.WriteProcessMemory(MemoryAddress, new byte[] { byteToWrite }, out bytesWritten);
                CloseProvider();
            }
            catch
            {
                bytesWritten = 0x00;
            }  
        }
        #endregion
        #region public virtual void WriteProcessMemory(uint MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
        public virtual void WriteProcessMemory(uint MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
        {
            try
            {
                OpenProvider();
                provider.WriteProcessMemory(MemoryAddress, bytesToWrite, out bytesWritten);
                CloseProvider();
            }
            catch
            {
                bytesWritten = 0x00;
            }  
        }
        #endregion
        #endregion
        #endregion
        #region IFileWriter members
        #region  public virtual bool WriteProcessMemoryToFile(string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead)
        public virtual bool WriteProcessMemoryToFile(string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead)
        {
            try
            {
                OpenProvider();
                provider.WriteProcessMemoryToFile(filename, MemoryAddress, bytesToRead, out bytesRead);
                CloseProvider();
                return true;
            }
            catch
            {
                bytesRead = 0x00;
                return false;
            }
        }
        #endregion
        #endregion
    }
}
Revision:	235
Committed:	Sun Jun 3 12:44:26 2012 UTC (11 years, 6 months ago) by william
File size:	15421 byte(s)
Log Message:	change int in method to uint
#	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	public abstract class BaseMemoryProvider :
13	IPatchMemory,
14	IReadMemory,
15	IAcceptsProcess<Process>,
16	IAcceptsPlugin<IConfigPlugin>,
17	IMemoryReader,
18	IMemoryWriter,
19	IFileWriter
20	{
21	private ProcessMemoryReader provider;
22	public BaseMemoryProvider() { this.AcceptedPlugin = null; this.AcceptedProcess = null; }
23	public BaseMemoryProvider(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }
24	public BaseMemoryProvider(IConfigPlugin config, Process process) : this() { this.AcceptedPlugin = config; this.AcceptedProcess = process; }
25	public BaseMemoryProvider(IAcceptsProcessAndConfig config) : this() { this.AcceptedPlugin = config.AcceptedPlugin; this.AcceptedProcess = config.AcceptedProcess; }
26
27	protected virtual void OpenProvider()
28	{
29	provider = new ProcessMemoryReader();
30	provider.ReadProcess = this.AcceptedProcess;
31	if (provider.ReadProcess == null) { logger.Error.WriteLine("{0}.OpenProvider() Could not attach to process: {1}", "",this.GetType().Name, this.AcceptedProcess.ToString()); return; }
32	provider.OpenProcess();
33	}
34	protected virtual void CloseProvider()
35	{
36	if (provider == null) return;
37	provider.CloseHandle();
38	provider = null; // free any memory associated with the provider
39	}
40	#region IAcceptsProcess<Process> Members
41	public Process AcceptedProcess { get; set; }
42	#endregion
43	#region IAcceptsPlugin<IConfigPlugin> Members
44	public IConfigPlugin AcceptedPlugin { get; set; }
45	#endregion
46	#region IPatchMemory members
47	#region public virtual bool PatchMemory(uint address, byte value)
48	public virtual bool PatchMemory(uint address, byte value)
49	{
50	OpenProvider();
51	int bytesWritten;
52	byte[] bitData = BitConverter.GetBytes(value);
53	provider.WriteProcessMemory(address, bitData, out bytesWritten);
54	CloseProvider();
55	byte check = 0;
56	ReadMemory(address, out check);
57	if (check == value) return true;
58	return false;
59	}
60	#endregion
61	#region public virtual bool PatchMemory(uint address, sbyte value)
62	public virtual bool PatchMemory(uint address, sbyte value)
63	{
64	OpenProvider();
65	int bytesWritten;
66	byte[] bitData = BitConverter.GetBytes(value);
67	provider.WriteProcessMemory(address, bitData, out bytesWritten);
68	CloseProvider();
69	sbyte check = 0;
70	ReadMemory(address, out check);
71	if (check == value) return true;
72	return false;
73	}
74	#endregion
75	#region public virtual bool PatchMemory(uint address, ushort value)
76	public virtual bool PatchMemory(uint address, ushort value)
77	{
78	OpenProvider();
79	int bytesWritten;
80	byte[] bitData = BitConverter.GetBytes(value);
81	provider.WriteProcessMemory(address, bitData, out bytesWritten);
82	CloseProvider();
83	ushort check = 0;
84	ReadMemory(address, out check);
85	if (check == value) return true;
86	return false;
87	}
88	#endregion
89	#region public virtual bool PatchMemory(uint address, short value)
90	public virtual bool PatchMemory(uint address, short value)
91	{
92	OpenProvider();
93	int bytesWritten;
94	byte[] bitData = BitConverter.GetBytes(value);
95	provider.WriteProcessMemory(address, bitData, out bytesWritten);
96	CloseProvider();
97	short check = 0;
98	ReadMemory(address, out check);
99	if (check == value) return true;
100	return false;
101	}
102	#endregion
103	#region public virtual bool PatchMemory(uint address, uint value)
104	public virtual bool PatchMemory(uint address, uint value)
105	{
106	OpenProvider();
107	int bytesWritten;
108	byte[] bitData = BitConverter.GetBytes(value);
109	provider.WriteProcessMemory(address, bitData, out bytesWritten);
110	CloseProvider();
111	uint check = 0;
112	ReadMemory(address, out check);
113	if (check == value) return true;
114	return false;
115	}
116	#endregion
117	#region public virtual bool PatchMemory(uint address, int value)
118	public virtual bool PatchMemory(uint address, int value)
119	{
120	OpenProvider();
121	int bytesWritten;
122	byte[] bitData = BitConverter.GetBytes(value);
123	provider.WriteProcessMemory(address, bitData, out bytesWritten);
124	CloseProvider();
125	int check = 0;
126	ReadMemory(address, out check);
127	if (check == value) return true;
128	return false;
129	}
130	#endregion
131	#region public virtual bool PatchMemory(uint address, ulong value)
132	public virtual bool PatchMemory(uint address, ulong value)
133	{
134	OpenProvider();
135	int bytesWritten;
136	byte[] bitData = BitConverter.GetBytes(value);
137	provider.WriteProcessMemory(address, bitData, out bytesWritten);
138	CloseProvider();
139	ulong check = 0;
140	ReadMemory(address, out check);
141	if (check == value) return true;
142	return false;
143	}
144	#endregion
145	#region public virtual bool PatchMemory(uint address, long value)
146	public virtual bool PatchMemory(uint address, long value)
147	{
148	OpenProvider();
149	int bytesWritten;
150	byte[] bitData = BitConverter.GetBytes(value);
151	provider.WriteProcessMemory(address, bitData, out bytesWritten);
152	CloseProvider();
153	long check = 0;
154	ReadMemory(address, out check);
155	if (check == value) return true;
156	return false;
157	}
158	#endregion
159	#endregion
160
161	#region IReadMemory members
162	#region public virtual bool ReadMemory(uint address, out byte value)
163	public virtual bool ReadMemory(uint address, out byte value)
164	{
165	try
166	{
167	value = 0;
168	OpenProvider();
169	int bytesReadSize;
170	byte[] bitData;
171	provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
172	value = bitData[0];
173	CloseProvider();
174	return true;
175	}
176	catch
177	{
178	value = 0x00;
179	return false;
180	}
181	}
182	#endregion
183	#region public virtual bool ReadMemory(uint address, out sbyte value)
184	public virtual bool ReadMemory(uint address, out sbyte value)
185	{
186	try
187	{
188	value = 0;
189	OpenProvider();
190	int bytesReadSize;
191	byte[] bitData;
192	provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
193	value = Convert.ToSByte(bitData[0]);
194	CloseProvider();
195	return true;
196	}
197	catch
198	{
199	value = 0x00;
200	return false;
201	}
202	}
203	#endregion
204	#region public virtual bool ReadMemory(uint address, out ushort value)
205	public virtual bool ReadMemory(uint address, out ushort value)
206	{
207	try
208	{
209	value = 0;
210	OpenProvider();
211	int bytesReadSize;
212	byte[] bitData;
213	provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
214	value = BitConverter.ToUInt16(bitData, 0);
215	CloseProvider();
216	return true;
217	}
218	catch
219	{
220	value = 0x00;
221	return false;
222	}
223	}
224	#endregion
225	#region public virtual bool ReadMemory(uint address, out short value)
226	public virtual bool ReadMemory(uint address, out short value)
227	{
228	try
229	{
230	value = 0;
231	OpenProvider();
232	int bytesReadSize;
233	byte[] bitData;
234	provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
235	value = BitConverter.ToInt16(bitData, 0);
236	CloseProvider();
237	return true;
238	}
239	catch
240	{
241	value = 0x00;
242	return false;
243	}
244	}
245	#endregion
246	#region public virtual bool ReadMemory(uint address, out uint value)
247	public virtual bool ReadMemory(uint address, out uint value)
248	{
249	try
250	{
251	value = 0;
252	OpenProvider();
253	int bytesReadSize;
254	byte[] bitData;
255	provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
256	value = BitConverter.ToUInt32(bitData, 0);
257	CloseProvider();
258	return true;
259	}
260	catch
261	{
262	value = 0x00;
263	return false;
264	}
265	}
266	#endregion
267	#region public virtual bool ReadMemory(uint address, out int value)
268	public virtual bool ReadMemory(uint address, out int value)
269	{
270	try
271	{
272	value = 0;
273	OpenProvider();
274	int bytesReadSize;
275	byte[] bitData;
276	provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
277	value = BitConverter.ToInt32(bitData, 0);
278	CloseProvider();
279	return true;
280	}
281	catch
282	{
283	value = 0x00;
284	return false;
285	}
286	}
287	#endregion
288	#region public virtual bool ReadMemory(uint address, out ulong value)
289	public virtual bool ReadMemory(uint address, out ulong value)
290	{
291	try
292	{
293	value = 0;
294	OpenProvider();
295	int bytesReadSize;
296	byte[] bitData;
297	provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
298	value = BitConverter.ToUInt64(bitData, 0);
299	CloseProvider();
300	return true;
301	}
302	catch
303	{
304	value = 0x00;
305	return false;
306	}
307	}
308	#endregion
309	#region public virtual bool ReadMemory(uint address, out long value)
310	public virtual bool ReadMemory(uint address, out long value)
311	{
312	try
313	{
314	value = 0;
315	OpenProvider();
316	int bytesReadSize;
317	byte[] bitData;
318	provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
319	value = BitConverter.ToInt64(bitData, 0);
320	CloseProvider();
321	return true;
322	}
323	catch
324	{
325	value = 0x00;
326	return false;
327	}
328	}
329	#endregion
330	#endregion
331
332	#region IMemoryReader members
333	#region public virtual bool ReadFirstNonZeroByte(uint MemoryAddress, uint bytesToRead, out uint address)
334	public virtual bool ReadFirstNonZeroByte(uint MemoryAddress, uint bytesToRead, out uint address)
335	{
336	try
337	{
338	OpenProvider();
339	provider.ReadFirstNonZeroByte(MemoryAddress, bytesToRead, out address);
340	CloseProvider();
341	return true;
342	}
343	catch
344	{
345	address = 0x00;
346	return false;
347	}
348	}
349	#endregion
350	#region public virtual void ReadProcessMemory(uint MemoryAddress, int bytesToRead, out int bytesRead, out byte[] data)
351	public virtual void ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
352	{
353	try
354	{
355	OpenProvider();
356	provider.ReadProcessMemory(MemoryAddress, bytesToRead, out bytesRead, out data);
357	CloseProvider();
358	}
359	catch
360	{
361	bytesRead = 0x00;
362	data = new byte[] { };
363	}
364	}
365	#endregion
366	#region IMemoryWriter members
367	#region public virtual void WriteProcessMemory(uint MemoryAddress, byte byteToWrite, out int bytesWritten)
368	public virtual void WriteProcessMemory(uint MemoryAddress, byte byteToWrite, out int bytesWritten)
369	{
370	try
371	{
372	OpenProvider();
373	provider.WriteProcessMemory(MemoryAddress, new byte[] { byteToWrite }, out bytesWritten);
374	CloseProvider();
375	}
376	catch
377	{
378	bytesWritten = 0x00;
379	}
380	}
381	#endregion
382	#region public virtual void WriteProcessMemory(uint MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
383	public virtual void WriteProcessMemory(uint MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
384	{
385	try
386	{
387	OpenProvider();
388	provider.WriteProcessMemory(MemoryAddress, bytesToWrite, out bytesWritten);
389	CloseProvider();
390	}
391	catch
392	{
393	bytesWritten = 0x00;
394	}
395	}
396	#endregion
397	#endregion
398	#endregion
399	#region IFileWriter members
400	#region public virtual bool WriteProcessMemoryToFile(string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead)
401	public virtual bool WriteProcessMemoryToFile(string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead)
402	{
403	try
404	{
405	OpenProvider();
406	provider.WriteProcessMemoryToFile(filename, MemoryAddress, bytesToRead, out bytesRead);
407	CloseProvider();
408	return true;
409	}
410	catch
411	{
412	bytesRead = 0x00;
413	return false;
414	}
415	}
416	#endregion
417	#endregion
418	}
419	}