ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/RomCheater/trunk/Win32/Sojaner.MemoryScanner/MemoryProviers/BaseMemoryProvider.cs
(Generate patch)

Comparing trunk/Win32/Sojaner.MemoryScanner/MemoryProviers/BaseMemoryProvider.cs (file contents):
Revision 254 by william, Sun Jun 3 16:32:58 2012 UTC vs.
Revision 255 by william, Sun Jun 3 16:45:47 2012 UTC

# Line 11 | Line 11 | namespace Sojaner.MemoryScanner.MemoryPr
11   {
12      #region public abstract class BaseMemoryProvider
13      public abstract class BaseMemoryProvider :
14 <        IPatchMemory,
15 <        IReadMemory,
14 >        IPatchMemory,
15 >        IReadMemory,
16          IAcceptsProcess<Process>,
17          IAcceptsPlugin<IConfigPlugin>,
18          IMemoryReader,
# Line 49 | Line 49 | namespace Sojaner.MemoryScanner.MemoryPr
49              }
50              catch (Exception ex)
51              {
52 <                logger.Error.WriteLine("Failed to open provider: {0}{1}",System.Environment.NewLine, ex.ToString());
52 >                logger.Error.WriteLine("Failed to open provider: {0}{1}", System.Environment.NewLine, ex.ToString());
53                  isOpen = false;
54                  isClosed = true;
55              }
# Line 58 | Line 58 | namespace Sojaner.MemoryScanner.MemoryPr
58          #region public virtual void CloseProvider()
59          public virtual void CloseProvider()
60          {
61 <            if (isClosed)
61 >            if (isClosed)
62              {
63                  logger.Warn.WriteLine("Provider has already been closed.");
64                  return;
# Line 157 | Line 157 | namespace Sojaner.MemoryScanner.MemoryPr
157              int bytesWritten;
158              byte[] bitData = BitConverter.GetBytes(value);
159              provider.WriteProcessMemory(address, bitData, out bytesWritten);
160 <            
160 >
161              ushort check = 0;
162              ReadMemory(address, out check);
163              if (check == value) return true;
# Line 171 | Line 171 | namespace Sojaner.MemoryScanner.MemoryPr
171              int bytesWritten;
172              byte[] bitData = BitConverter.GetBytes(value);
173              provider.WriteProcessMemory(address, bitData, out bytesWritten);
174 <            
174 >
175              short check = 0;
176              ReadMemory(address, out check);
177              if (check == value) return true;
# Line 185 | Line 185 | namespace Sojaner.MemoryScanner.MemoryPr
185              int bytesWritten;
186              byte[] bitData = BitConverter.GetBytes(value);
187              provider.WriteProcessMemory(address, bitData, out bytesWritten);
188 <            
188 >
189              uint check = 0;
190              ReadMemory(address, out check);
191              if (check == value) return true;
# Line 199 | Line 199 | namespace Sojaner.MemoryScanner.MemoryPr
199              int bytesWritten;
200              byte[] bitData = BitConverter.GetBytes(value);
201              provider.WriteProcessMemory(address, bitData, out bytesWritten);
202 <            
202 >
203              int check = 0;
204              ReadMemory(address, out check);
205              if (check == value) return true;
# Line 213 | Line 213 | namespace Sojaner.MemoryScanner.MemoryPr
213              int bytesWritten;
214              byte[] bitData = BitConverter.GetBytes(value);
215              provider.WriteProcessMemory(address, bitData, out bytesWritten);
216 <            
216 >
217              ulong check = 0;
218              ReadMemory(address, out check);
219              if (check == value) return true;
# Line 227 | Line 227 | namespace Sojaner.MemoryScanner.MemoryPr
227              int bytesWritten;
228              byte[] bitData = BitConverter.GetBytes(value);
229              provider.WriteProcessMemory(address, bitData, out bytesWritten);
230 <            
230 >
231              long check = 0;
232              ReadMemory(address, out check);
233              if (check == value) return true;
# Line 241 | Line 241 | namespace Sojaner.MemoryScanner.MemoryPr
241          public virtual bool ReadMemory(int address, out byte value)
242          {
243              value = 0;
244 <             if (!EnsureProviderIsOpen()) { return false; }
244 >            if (!EnsureProviderIsOpen()) { return false; }
245              try
246 <            {   int bytesReadSize;
246 >            {
247 >                int bytesReadSize;
248                  byte[] bitData;
249                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
250                  value = bitData[0];
251 <                
251 >
252                  return true;
253              }
254              catch
# Line 263 | Line 264 | namespace Sojaner.MemoryScanner.MemoryPr
264              value = 0;
265              if (!EnsureProviderIsOpen()) { return false; }
266              try
267 <            {  
267 >            {
268                  int bytesReadSize;
269                  byte[] bitData;
270                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
271                  value = Convert.ToSByte(bitData[0]);
272 <                
272 >
273                  return true;
274              }
275              catch
# Line 289 | Line 290 | namespace Sojaner.MemoryScanner.MemoryPr
290                  byte[] bitData;
291                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
292                  value = BitConverter.ToUInt16(bitData, 0);
293 <                
293 >
294                  return true;
295              }
296              catch
# Line 310 | Line 311 | namespace Sojaner.MemoryScanner.MemoryPr
311                  byte[] bitData;
312                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
313                  value = BitConverter.ToInt16(bitData, 0);
314 <                
314 >
315                  return true;
316              }
317              catch
# Line 331 | Line 332 | namespace Sojaner.MemoryScanner.MemoryPr
332                  byte[] bitData;
333                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
334                  value = BitConverter.ToUInt32(bitData, 0);
335 <                
335 >
336                  return true;
337              }
338              catch
# Line 352 | Line 353 | namespace Sojaner.MemoryScanner.MemoryPr
353                  byte[] bitData;
354                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
355                  value = BitConverter.ToInt32(bitData, 0);
356 <                
356 >
357                  return true;
358              }
359              catch
# Line 373 | Line 374 | namespace Sojaner.MemoryScanner.MemoryPr
374                  byte[] bitData;
375                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
376                  value = BitConverter.ToUInt64(bitData, 0);
377 <                
377 >
378                  return true;
379              }
380              catch
# Line 394 | Line 395 | namespace Sojaner.MemoryScanner.MemoryPr
395                  byte[] bitData;
396                  provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
397                  value = BitConverter.ToInt64(bitData, 0);
398 <                
398 >
399                  return true;
400              }
401              catch
# Line 415 | Line 416 | namespace Sojaner.MemoryScanner.MemoryPr
416              try { provider.ReadFirstNonZeroByte(MemoryAddress, bytesToRead, out address); return true; }
417              catch { address = 0x00; return false; }
418          }
419 <        #endregion      
419 >        #endregion
420          #region public virtual void ReadProcessMemory(int MemoryAddress, int bytesToRead, out int bytesRead, out byte[] data)
421          public virtual void ReadProcessMemory(int MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
422          {
# Line 461 | Line 462 | namespace Sojaner.MemoryScanner.MemoryPr
462          #endregion
463      }
464      #endregion
465 <
465 <    #region MemoryScanner-r204
466 <    namespace r204
467 <    {
468 <        #region public abstract class BaseMemoryProvider
469 <        public abstract class BaseMemoryProvider :
470 <            IPatchMemory,
471 <            IReadMemory,
472 <            IAcceptsProcess<Process>,
473 <            IAcceptsPlugin<IConfigPlugin>,
474 <            IMemoryReader,
475 <            IMemoryWriter,
476 <            IFileWriter
477 <        {
478 <            private Sojaner.MemoryScanner.r204.ProcessMemoryReader provider;
479 <            public BaseMemoryProvider() { this.AcceptedPlugin = null; this.AcceptedProcess = null; isClosed = true; isOpen = false; }
480 <            public BaseMemoryProvider(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }
481 <            public BaseMemoryProvider(IConfigPlugin config, Process process) : this() { this.AcceptedPlugin = config; this.AcceptedProcess = process; }
482 <            public BaseMemoryProvider(IAcceptsProcessAndConfig config) : this() { this.AcceptedPlugin = config.AcceptedPlugin; this.AcceptedProcess = config.AcceptedProcess; }
483 <
484 <
485 <            private bool isOpen { get; set; }
486 <            private bool isClosed { get; set; }
487 <
488 <            #region Open/Close Provider
489 <            #region public virtual void OpenProvider()
490 <            public virtual void OpenProvider()
491 <            {
492 <                if (isOpen)
493 <                {
494 <                    logger.Warn.WriteLine("Provider has already been opened.");
495 <                    return;
496 <                }
497 <                try
498 <                {
499 <                    provider = new Sojaner.MemoryScanner.r204.ProcessMemoryReader();
500 <                    provider.ReadProcess = this.AcceptedProcess;
501 <                    if (provider.ReadProcess == null) { logger.Error.WriteLine("{0}.OpenProvider() Could not attach to process: {1}", "", this.GetType().Name, this.AcceptedProcess.ToString()); return; }
502 <                    provider.OpenProcess();
503 <                    isOpen = true;
504 <                    isClosed = false;
505 <                }
506 <                catch (Exception ex)
507 <                {
508 <                    logger.Error.WriteLine("Failed to open provider: {0}{1}", System.Environment.NewLine, ex.ToString());
509 <                    isOpen = false;
510 <                    isClosed = true;
511 <                }
512 <            }
513 <            #endregion
514 <            #region public virtual void CloseProvider()
515 <            public virtual void CloseProvider()
516 <            {
517 <                if (isClosed)
518 <                {
519 <                    logger.Warn.WriteLine("Provider has already been closed.");
520 <                    return;
521 <                }
522 <                if (!isOpen)
523 <                {
524 <                    logger.Warn.WriteLine("Provider cannot be closed, it was never opened...attempting to open provider.");
525 <                    OpenProvider();
526 <                    if (!isOpen)
527 <                    {
528 <                        logger.Warn.WriteLine("Could not open provider");
529 <                        return;
530 <                    }
531 <                }
532 <                try
533 <                {
534 <                    //logger.VerboseDebug.WriteLine("CloseProvider(): System.Environment.StackTrace: {0}{1}", System.Environment.NewLine, System.Environment.StackTrace);
535 <                    if (provider == null) return;
536 <                    provider.CloseHandle();
537 <                    //provider = null; // free any memory associated with the provider
538 <                    isClosed = true;
539 <                    isOpen = false;
540 <                }
541 <                catch (Exception ex)
542 <                {
543 <                    logger.Error.WriteLine("Failed to close provider: {0}{1}", System.Environment.NewLine, ex.ToString());
544 <                    isClosed = false;
545 <                    if (isOpen)
546 <                    {
547 <                        throw new Exception("Provider is failed to close and still open.");
548 <                    }
549 <                }
550 <            }
551 <            #endregion
552 <            #endregion
553 <
554 <            #region  IAcceptsProcess<Process> Members
555 <            public Process AcceptedProcess { get; set; }
556 <            #endregion
557 <            #region IAcceptsPlugin<IConfigPlugin> Members
558 <            public IConfigPlugin AcceptedPlugin { get; set; }
559 <            #endregion
560 <            #region EnsureProviderIsOpen methods : log and/or throw errors
561 <            private bool EnsureProviderIsOpen() { return EnsureProviderIsOpenOrThrowError(); }
562 <            private bool EnsureProviderIsOpenOrLogError() { return EnsureProviderIsOpenOrThrowOrLogError(false, true); }
563 <            private bool EnsureProviderIsOpenOrThrowError() { return EnsureProviderIsOpenOrThrowOrLogError(true, true); }
564 <            private bool EnsureProviderIsOpenOrThrowOrLogError(bool ThrowError, bool LogError)
565 <            {
566 <                if (!isOpen)
567 <                {
568 <                    try { throw new Exception("Memory operation could not be completed because the provider is not open"); }
569 <                    catch (Exception ex)
570 <                    {
571 <                        if (LogError)
572 <                            logger.Error.WriteLine(ex.ToString());
573 <                        if (ThrowError)
574 <                            throw ex;
575 <                        return false;
576 <                    }
577 <                }
578 <                return true;
579 <            }
580 <            #endregion
581 <
582 <            #region IPatchMemory members
583 <            #region public virtual bool PatchMemory(int address, byte value)
584 <            public virtual bool PatchMemory(int address, byte value)
585 <            {
586 <                if (!EnsureProviderIsOpen()) { return false; }
587 <                int bytesWritten;
588 <                byte[] bitData = BitConverter.GetBytes(value);
589 <                provider.WriteProcessMemory(address, bitData, out bytesWritten);
590 <                byte check = 0;
591 <                ReadMemory(address, out check);
592 <                if (check == value) return true;
593 <                return false;
594 <            }
595 <            #endregion
596 <            #region public virtual bool PatchMemory(int address, sbyte value)
597 <            public virtual bool PatchMemory(int address, sbyte value)
598 <            {
599 <                if (!EnsureProviderIsOpen()) { return false; }
600 <                int bytesWritten;
601 <                byte[] bitData = BitConverter.GetBytes(value);
602 <                provider.WriteProcessMemory(address, bitData, out bytesWritten);
603 <                sbyte check = 0;
604 <                ReadMemory(address, out check);
605 <                if (check == value) return true;
606 <                return false;
607 <            }
608 <            #endregion
609 <            #region public virtual bool PatchMemory(int address, ushort value)
610 <            public virtual bool PatchMemory(int address, ushort value)
611 <            {
612 <                if (!EnsureProviderIsOpen()) { return false; }
613 <                int bytesWritten;
614 <                byte[] bitData = BitConverter.GetBytes(value);
615 <                provider.WriteProcessMemory(address, bitData, out bytesWritten);
616 <
617 <                ushort check = 0;
618 <                ReadMemory(address, out check);
619 <                if (check == value) return true;
620 <                return false;
621 <            }
622 <            #endregion
623 <            #region public virtual bool PatchMemory(int address, short value)
624 <            public virtual bool PatchMemory(int address, short value)
625 <            {
626 <                if (!EnsureProviderIsOpen()) { return false; }
627 <                int bytesWritten;
628 <                byte[] bitData = BitConverter.GetBytes(value);
629 <                provider.WriteProcessMemory(address, bitData, out bytesWritten);
630 <
631 <                short check = 0;
632 <                ReadMemory(address, out check);
633 <                if (check == value) return true;
634 <                return false;
635 <            }
636 <            #endregion
637 <            #region public virtual bool PatchMemory(int address, uint value)
638 <            public virtual bool PatchMemory(int address, uint value)
639 <            {
640 <                if (!EnsureProviderIsOpen()) { return false; }
641 <                int bytesWritten;
642 <                byte[] bitData = BitConverter.GetBytes(value);
643 <                provider.WriteProcessMemory(address, bitData, out bytesWritten);
644 <
645 <                uint check = 0;
646 <                ReadMemory(address, out check);
647 <                if (check == value) return true;
648 <                return false;
649 <            }
650 <            #endregion
651 <            #region public virtual bool PatchMemory(int address, int value)
652 <            public virtual bool PatchMemory(int address, int value)
653 <            {
654 <                if (!EnsureProviderIsOpen()) { return false; }
655 <                int bytesWritten;
656 <                byte[] bitData = BitConverter.GetBytes(value);
657 <                provider.WriteProcessMemory(address, bitData, out bytesWritten);
658 <
659 <                int check = 0;
660 <                ReadMemory(address, out check);
661 <                if (check == value) return true;
662 <                return false;
663 <            }
664 <            #endregion
665 <            #region public virtual bool PatchMemory(int address, ulong value)
666 <            public virtual bool PatchMemory(int address, ulong value)
667 <            {
668 <                if (!EnsureProviderIsOpen()) { return false; }
669 <                int bytesWritten;
670 <                byte[] bitData = BitConverter.GetBytes(value);
671 <                provider.WriteProcessMemory(address, bitData, out bytesWritten);
672 <
673 <                ulong check = 0;
674 <                ReadMemory(address, out check);
675 <                if (check == value) return true;
676 <                return false;
677 <            }
678 <            #endregion
679 <            #region public virtual bool PatchMemory(int address, long value)
680 <            public virtual bool PatchMemory(int address, long value)
681 <            {
682 <                if (!EnsureProviderIsOpen()) { return false; }
683 <                int bytesWritten;
684 <                byte[] bitData = BitConverter.GetBytes(value);
685 <                provider.WriteProcessMemory(address, bitData, out bytesWritten);
686 <
687 <                long check = 0;
688 <                ReadMemory(address, out check);
689 <                if (check == value) return true;
690 <                return false;
691 <            }
692 <            #endregion
693 <            #endregion
694 <
695 <            #region IReadMemory members
696 <            #region public virtual bool ReadMemory(int address, out byte value)
697 <            public virtual bool ReadMemory(int address, out byte value)
698 <            {
699 <                value = 0;
700 <                if (!EnsureProviderIsOpen()) { return false; }
701 <                try
702 <                {
703 <                    int bytesReadSize;
704 <                    byte[] bitData;
705 <                    provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
706 <                    value = bitData[0];
707 <
708 <                    return true;
709 <                }
710 <                catch
711 <                {
712 <                    value = 0x00;
713 <                    return false;
714 <                }
715 <            }
716 <            #endregion
717 <            #region public virtual bool ReadMemory(int address, out sbyte value)
718 <            public virtual bool ReadMemory(int address, out sbyte value)
719 <            {
720 <                value = 0;
721 <                if (!EnsureProviderIsOpen()) { return false; }
722 <                try
723 <                {
724 <                    int bytesReadSize;
725 <                    byte[] bitData;
726 <                    provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
727 <                    value = Convert.ToSByte(bitData[0]);
728 <
729 <                    return true;
730 <                }
731 <                catch
732 <                {
733 <                    value = 0x00;
734 <                    return false;
735 <                }
736 <            }
737 <            #endregion
738 <            #region public virtual bool ReadMemory(int address, out ushort value)
739 <            public virtual bool ReadMemory(int address, out ushort value)
740 <            {
741 <                value = 0;
742 <                if (!EnsureProviderIsOpen()) { return false; }
743 <                try
744 <                {
745 <                    int bytesReadSize;
746 <                    byte[] bitData;
747 <                    provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
748 <                    value = BitConverter.ToUInt16(bitData, 0);
749 <
750 <                    return true;
751 <                }
752 <                catch
753 <                {
754 <                    value = 0x00;
755 <                    return false;
756 <                }
757 <            }
758 <            #endregion
759 <            #region public virtual bool ReadMemory(int address, out short value)
760 <            public virtual bool ReadMemory(int address, out short value)
761 <            {
762 <                value = 0;
763 <                if (!EnsureProviderIsOpen()) { return false; }
764 <                try
765 <                {
766 <                    int bytesReadSize;
767 <                    byte[] bitData;
768 <                    provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
769 <                    value = BitConverter.ToInt16(bitData, 0);
770 <
771 <                    return true;
772 <                }
773 <                catch
774 <                {
775 <                    value = 0x00;
776 <                    return false;
777 <                }
778 <            }
779 <            #endregion
780 <            #region public virtual bool ReadMemory(int address, out uint value)
781 <            public virtual bool ReadMemory(int address, out uint value)
782 <            {
783 <                value = 0;
784 <                if (!EnsureProviderIsOpen()) { return false; }
785 <                try
786 <                {
787 <                    int bytesReadSize;
788 <                    byte[] bitData;
789 <                    provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
790 <                    value = BitConverter.ToUInt32(bitData, 0);
791 <
792 <                    return true;
793 <                }
794 <                catch
795 <                {
796 <                    value = 0x00;
797 <                    return false;
798 <                }
799 <            }
800 <            #endregion
801 <            #region public virtual bool ReadMemory(int address, out int value)
802 <            public virtual bool ReadMemory(int address, out int value)
803 <            {
804 <                value = 0;
805 <                if (!EnsureProviderIsOpen()) { return false; }
806 <                try
807 <                {
808 <                    int bytesReadSize;
809 <                    byte[] bitData;
810 <                    provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
811 <                    value = BitConverter.ToInt32(bitData, 0);
812 <
813 <                    return true;
814 <                }
815 <                catch
816 <                {
817 <                    value = 0x00;
818 <                    return false;
819 <                }
820 <            }
821 <            #endregion
822 <            #region public virtual bool ReadMemory(int address, out ulong value)
823 <            public virtual bool ReadMemory(int address, out ulong value)
824 <            {
825 <                value = 0;
826 <                if (!EnsureProviderIsOpen()) { return false; }
827 <                try
828 <                {
829 <                    int bytesReadSize;
830 <                    byte[] bitData;
831 <                    provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
832 <                    value = BitConverter.ToUInt64(bitData, 0);
833 <
834 <                    return true;
835 <                }
836 <                catch
837 <                {
838 <                    value = 0x00;
839 <                    return false;
840 <                }
841 <            }
842 <            #endregion
843 <            #region public virtual bool ReadMemory(int address, out long value)
844 <            public virtual bool ReadMemory(int address, out long value)
845 <            {
846 <                value = 0;
847 <                if (!EnsureProviderIsOpen()) { return false; }
848 <                try
849 <                {
850 <                    int bytesReadSize;
851 <                    byte[] bitData;
852 <                    provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
853 <                    value = BitConverter.ToInt64(bitData, 0);
854 <
855 <                    return true;
856 <                }
857 <                catch
858 <                {
859 <                    value = 0x00;
860 <                    return false;
861 <                }
862 <            }
863 <            #endregion
864 <            #endregion
865 <
866 <            #region IMemoryReader members
867 <            #region public virtual bool ReadFirstNonZeroByte(int MemoryAddress, uint bytesToRead, out int address)
868 <            public virtual bool ReadFirstNonZeroByte(int MemoryAddress, uint bytesToRead, out int address)
869 <            {
870 <                address = 0;
871 <                if (!EnsureProviderIsOpen()) { return false; }
872 <                try { provider.ReadFirstNonZeroByte(MemoryAddress, bytesToRead, out address); return true; }
873 <                catch { address = 0x00; return false; }
874 <            }
875 <            #endregion
876 <            #region public virtual void ReadProcessMemory(int MemoryAddress, int bytesToRead, out int bytesRead, out byte[] data)
877 <            public virtual void ReadProcessMemory(int MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
878 <            {
879 <                bytesRead = 0x00;
880 <                data = new byte[] { };
881 <                if (!EnsureProviderIsOpen()) { return; }
882 <                try { provider.ReadProcessMemory(MemoryAddress, bytesToRead, out bytesRead, out data); }
883 <                catch { bytesRead = 0x00; data = new byte[] { }; }
884 <            }
885 <            #endregion
886 <            #region IMemoryWriter members
887 <            #region public virtual void WriteProcessMemory(int MemoryAddress, byte byteToWrite, out int bytesWritten)
888 <            public virtual void WriteProcessMemory(int MemoryAddress, byte byteToWrite, out int bytesWritten)
889 <            {
890 <                bytesWritten = 0;
891 <                if (!EnsureProviderIsOpen()) { return; }
892 <                try { provider.WriteProcessMemory(MemoryAddress, new byte[] { byteToWrite }, out bytesWritten); }
893 <                catch { bytesWritten = 0x00; }
894 <            }
895 <            #endregion
896 <            #region public virtual void WriteProcessMemory(int MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
897 <            public virtual void WriteProcessMemory(int MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
898 <            {
899 <                bytesWritten = 0;
900 <                if (!EnsureProviderIsOpen()) { return; }
901 <                try { provider.WriteProcessMemory(MemoryAddress, bytesToWrite, out bytesWritten); }
902 <                catch { bytesWritten = 0x00; }
903 <            }
904 <            #endregion
905 <            #endregion
906 <            #endregion
907 <            #region IFileWriter members
908 <            #region  public virtual bool WriteProcessMemoryToFile(string filename, int MemoryAddress, uint bytesToRead, out int bytesRead)
909 <            public virtual bool WriteProcessMemoryToFile(string filename, int MemoryAddress, uint bytesToRead, out int bytesRead)
910 <            {
911 <                bytesRead = 0;
912 <                if (!EnsureProviderIsOpen()) { return false; }
913 <                try { provider.WriteProcessMemoryToFile(filename, MemoryAddress, bytesToRead, out bytesRead); return true; }
914 <                catch
915 <                { bytesRead = 0x00; return false; }
916 <            }
917 <            #endregion
918 <            #endregion
919 <        }
920 <        #endregion
921 <    }
922 <    #endregion
923 < }
465 > }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines