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 (10 years, 9 months ago) by william
File size:	15421 byte(s)
Log Message:	change int in method to uint
#	User	Rev	Content
1	william	231	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	william	235	public virtual bool ReadFirstNonZeroByte(uint MemoryAddress, uint bytesToRead, out uint address)
335	william	231	{
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	william	235	public virtual void ReadProcessMemory(uint MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
352	william	231	{
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	william	235	public virtual bool WriteProcessMemoryToFile(string filename, uint MemoryAddress, uint bytesToRead, out int bytesRead)
402	william	231	{
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			}