Ensure explicit getters and setters

PortableExecutable/OptionalHeader.cs

@@ -37,35 +37,35 @@
         /// common number is 0x10B, which identifies it as a normal executable file.
         /// 0x107 identifies it as a ROM image, and 0x20B identifies it as a PE32+ executable. 
         /// </summary>
-        public OptionalHeaderMagicNumber Magic;
+        public OptionalHeaderMagicNumber Magic { get; set; }
 
         /// <summary>
         /// The linker major version number.
         /// </summary>
-        public byte MajorLinkerVersion;
+        public byte MajorLinkerVersion { get; set; }
 
         /// <summary>
         /// The linker minor version number.
         /// </summary>
-        public byte MinorLinkerVersion;
+        public byte MinorLinkerVersion { get; set; }
 
         /// <summary>
         /// The size of the code (text) section, or the sum of all code sections if there
         /// are multiple sections.
         /// </summary>
-        public uint SizeOfCode;
+        public uint SizeOfCode { get; set; }
 
         /// <summary>
         /// The size of the initialized data section, or the sum of all such sections if
         /// there are multiple data sections.
         /// </summary>
-        public uint SizeOfInitializedData;
+        public uint SizeOfInitializedData { get; set; }
 
         /// <summary>
         /// The size of the uninitialized data section (BSS), or the sum of all such sections
         /// if there are multiple BSS sections.
         /// </summary>
-        public uint SizeOfUninitializedData;
+        public uint SizeOfUninitializedData { get; set; }
 
         /// <summary>
         /// The address of the entry point relative to the image base when the executable file
@@ -73,13 +73,13 @@
         /// device drivers, this is the address of the initialization function. An entry point
         /// is optional for DLLs. When no entry point is present, this field must be zero.
         /// </summary>
-        public uint AddressOfEntryPoint;
+        public uint AddressOfEntryPoint { get; set; }
 
         /// <summary>
         /// The address that is relative to the image base of the beginning-of-code section when
         /// it is loaded into memory. 
         /// </summary>
-        public uint BaseOfCode;
+        public uint BaseOfCode { get; set; }
 
         #region PE32-Only
 
@@ -87,7 +87,7 @@
         /// The address that is relative to the image base of the beginning-of-data section when
         /// it is loaded into memory. 
         /// </summary>
-        public uint BaseOfData;
+        public uint BaseOfData { get; set; }
 
         #endregion
 
@@ -98,20 +98,20 @@
         #region ImageBase
 
         /// <summary>
-        /// The preferred address of the first byte of image when loaded into memory;
+        /// The preferred address of the first byte of image when loaded into memory { get; set; }
         /// must be a multiple of 64 K. The default for DLLs is 0x10000000. The default
         /// for Windows CE EXEs is 0x00010000. The default for Windows NT, Windows 2000,
         /// Windows XP, Windows 95, Windows 98, and Windows Me is 0x00400000.
         /// </summary>
-        public uint ImageBase_PE32;
+        public uint ImageBase_PE32 { get; set; }
 
         /// <summary>
-        /// The preferred address of the first byte of image when loaded into memory;
+        /// The preferred address of the first byte of image when loaded into memory { get; set; }
         /// must be a multiple of 64 K. The default for DLLs is 0x10000000. The default
         /// for Windows CE EXEs is 0x00010000. The default for Windows NT, Windows 2000,
         /// Windows XP, Windows 95, Windows 98, and Windows Me is 0x00400000.
         /// </summary>
-        public ulong ImageBase_PE32Plus;
+        public ulong ImageBase_PE32Plus { get; set; }
 
         #endregion
 
@@ -120,7 +120,7 @@
         /// be greater than or equal to FileAlignment. The default is the page size for
         /// the architecture.
         /// </summary>
-        public uint SectionAlignment;
+        public uint SectionAlignment { get; set; }
 
         /// <summary>
         /// The alignment factor (in bytes) that is used to align the raw data of sections
@@ -128,54 +128,54 @@
         /// inclusive. The default is 512. If the SectionAlignment is less than the
         /// architecture's page size, then FileAlignment must match SectionAlignment.
         /// </summary>
-        public uint FileAlignment;
+        public uint FileAlignment { get; set; }
 
         /// <summary>
         /// The major version number of the required operating system.
         /// </summary>
-        public ushort MajorOperatingSystemVersion;
+        public ushort MajorOperatingSystemVersion { get; set; }
 
         /// <summary>
         /// The minor version number of the required operating system.
         /// </summary>
-        public ushort MinorOperatingSystemVersion;
+        public ushort MinorOperatingSystemVersion { get; set; }
 
         /// <summary>
         /// The major version number of the image.
         /// </summary>
-        public ushort MajorImageVersion;
+        public ushort MajorImageVersion { get; set; }
 
         /// <summary>
         /// The minor version number of the image.
         /// </summary>
-        public ushort MinorImageVersion;
+        public ushort MinorImageVersion { get; set; }
 
         /// <summary>
         /// The major version number of the subsystem.
         /// </summary>
-        public ushort MajorSubsystemVersion;
+        public ushort MajorSubsystemVersion { get; set; }
 
         /// <summary>
         /// The minor version number of the subsystem.
         /// </summary>
-        public ushort MinorSubsystemVersion;
+        public ushort MinorSubsystemVersion { get; set; }
 
         /// <summary>
         /// Reserved, must be zero.
         /// </summary>
-        public uint Win32VersionValue;
+        public uint Win32VersionValue { get; set; }
 
         /// <summary>
         /// The size (in bytes) of the image, including all headers, as the image
         /// is loaded in memory. It must be a multiple of SectionAlignment.
         /// </summary>
-        public uint SizeOfImage;
+        public uint SizeOfImage { get; set; }
 
         /// <summary>
         /// The combined size of an MS-DOS stub, PE header, and section headers rounded
         /// up to a multiple of FileAlignment.
         /// </summary>
-        public uint SizeOfHeaders;
+        public uint SizeOfHeaders { get; set; }
 
         /// <summary>
         /// The image file checksum. The algorithm for computing the checksum is
@@ -183,17 +183,17 @@
         /// load time: all drivers, any DLL loaded at boot time, and any DLL that is
         /// loaded into a critical Windows process.
         /// </summary>
-        public uint CheckSum;
+        public uint CheckSum { get; set; }
 
         /// <summary>
         /// The subsystem that is required to run this image.
         /// </summary>
-        public WindowsSubsystem Subsystem;
+        public WindowsSubsystem Subsystem { get; set; }
 
         /// <summary>
         /// DLL characteristics
         /// </summary>
-        public DllCharacteristics DllCharacteristics;
+        public DllCharacteristics DllCharacteristics { get; set; }
 
         #region SizeOfStackReserve
 
@@ -201,13 +201,13 @@
         /// The size of the stack to reserve. Only SizeOfStackCommit is committed; the rest
         /// is made available one page at a time until the reserve size is reached.
         /// </summary>
-        public uint SizeOfStackReserve_PE32;
+        public uint SizeOfStackReserve_PE32 { get; set; }
 
         /// <summary>
         /// The size of the stack to reserve. Only SizeOfStackCommit is committed; the rest
         /// is made available one page at a time until the reserve size is reached.
         /// </summary>
-        public ulong SizeOfStackReserve_PE32Plus;
+        public ulong SizeOfStackReserve_PE32Plus { get; set; }
 
         #endregion
 
@@ -216,12 +216,12 @@
         /// <summary>
         /// The size of the stack to commit. 
         /// </summary>
-        public uint SizeOfStackCommit_PE32;
+        public uint SizeOfStackCommit_PE32 { get; set; }
 
         /// <summary>
         /// The size of the stack to commit. 
         /// </summary>
-        public ulong SizeOfStackCommit_PE32Plus;
+        public ulong SizeOfStackCommit_PE32Plus { get; set; }
 
         #endregion
 
@@ -232,14 +232,14 @@
         /// committed; the rest is made available one page at a time until the reserve
         /// size is reached.
         /// </summary>
-        public uint SizeOfHeapReserve_PE32;
+        public uint SizeOfHeapReserve_PE32 { get; set; }
 
         /// <summary>
         /// The size of the local heap space to reserve. Only SizeOfHeapCommit is
         /// committed; the rest is made available one page at a time until the reserve
         /// size is reached.
         /// </summary>
-        public ulong SizeOfHeapReserve_PE32Plus;
+        public ulong SizeOfHeapReserve_PE32Plus { get; set; }
 
         #endregion
 
@@ -248,25 +248,25 @@
         /// <summary>
         /// The size of the local heap space to commit.
         /// </summary>
-        public uint SizeOfHeapCommit_PE32;
+        public uint SizeOfHeapCommit_PE32 { get; set; }
 
         /// <summary>
         /// The size of the local heap space to commit.
         /// </summary>
-        public ulong SizeOfHeapCommit_PE32Plus;
+        public ulong SizeOfHeapCommit_PE32Plus { get; set; }
 
         #endregion
 
         /// <summary>
         /// Reserved, must be zero.
         /// </summary>
-        public uint LoaderFlags;
+        public uint LoaderFlags { get; set; }
 
         /// <summary>
         /// The number of data-directory entries in the remainder of the optional header.
         /// Each describes a location and size.
         /// </summary>
-        public uint NumberOfRvaAndSizes;
+        public uint NumberOfRvaAndSizes { get; set; }
 
         #endregion
 
@@ -276,138 +276,138 @@
         /// The export table address and size.
         /// </summary>
 #if NET48
-        public DataDirectory ExportTable;
+        public DataDirectory ExportTable { get; set; }
 #else
-        public DataDirectory? ExportTable;
+        public DataDirectory? ExportTable { get; set; }
 #endif
 
         /// <summary>
         /// The import table address and size.
         /// </summary>
 #if NET48
-        public DataDirectory ImportTable;
+        public DataDirectory ImportTable { get; set; }
 #else
-        public DataDirectory? ImportTable;
+        public DataDirectory? ImportTable { get; set; }
 #endif
 
         /// <summary>
         /// The resource table address and size.
         /// </summary>
 #if NET48
-        public DataDirectory ResourceTable;
+        public DataDirectory ResourceTable { get; set; }
 #else
-        public DataDirectory? ResourceTable;
+        public DataDirectory? ResourceTable { get; set; }
 #endif
 
         /// <summary>
         /// The exception table address and size.
         /// </summary>
 #if NET48
-        public DataDirectory ExceptionTable;
+        public DataDirectory ExceptionTable { get; set; }
 #else
-        public DataDirectory? ExceptionTable;
+        public DataDirectory? ExceptionTable { get; set; }
 #endif
 
         /// <summary>
         /// The attribute certificate table address and size.
         /// </summary>
 #if NET48
-        public DataDirectory CertificateTable;
+        public DataDirectory CertificateTable { get; set; }
 #else
-        public DataDirectory? CertificateTable;
+        public DataDirectory? CertificateTable { get; set; }
 #endif
 
         /// <summary>
         /// The base relocation table address and size.
         /// </summary>
 #if NET48
-        public DataDirectory BaseRelocationTable;
+        public DataDirectory BaseRelocationTable { get; set; }
 #else
-        public DataDirectory? BaseRelocationTable;
+        public DataDirectory? BaseRelocationTable { get; set; }
 #endif
 
         /// <summary>
         /// The debug data starting address and size.
         /// </summary>
 #if NET48
-        public DataDirectory Debug;
+        public DataDirectory Debug { get; set; }
 #else
-        public DataDirectory? Debug;
+        public DataDirectory? Debug { get; set; }
 #endif
 
         /// <summary>
         /// Reserved, must be 0
         /// </summary>
-        public ulong Architecture;
+        public ulong Architecture { get; set; }
 
         /// <summary>
         /// The RVA of the value to be stored in the global pointer register.
         /// The size member of this structure must be set to zero.
         /// </summary>
 #if NET48
-        public DataDirectory GlobalPtr;
+        public DataDirectory GlobalPtr { get; set; }
 #else
-        public DataDirectory? GlobalPtr;
+        public DataDirectory? GlobalPtr { get; set; }
 #endif
 
         /// <summary>
         /// The thread local storage (TLS) table address and size.
         /// </summary>
 #if NET48
-        public DataDirectory ThreadLocalStorageTable;
+        public DataDirectory ThreadLocalStorageTable { get; set; }
 #else
-        public DataDirectory? ThreadLocalStorageTable;
+        public DataDirectory? ThreadLocalStorageTable { get; set; }
 #endif
 
         /// <summary>
         /// The load configuration table address and size.
         /// </summary>
 #if NET48
-        public DataDirectory LoadConfigTable;
+        public DataDirectory LoadConfigTable { get; set; }
 #else
-        public DataDirectory? LoadConfigTable;
+        public DataDirectory? LoadConfigTable { get; set; }
 #endif
 
         /// <summary>
         /// The bound import table address and size.
         /// </summary>
 #if NET48
-        public DataDirectory BoundImport;
+        public DataDirectory BoundImport { get; set; }
 #else
-        public DataDirectory? BoundImport;
+        public DataDirectory? BoundImport { get; set; }
 #endif
 
         /// <summary>
         /// The import address table address and size
         /// </summary>
 #if NET48
-        public DataDirectory ImportAddressTable;
+        public DataDirectory ImportAddressTable { get; set; }
 #else
-        public DataDirectory? ImportAddressTable;
+        public DataDirectory? ImportAddressTable { get; set; }
 #endif
 
         /// <summary>
         /// The delay import descriptor address and size.
         /// </summary>
 #if NET48
-        public DataDirectory DelayImportDescriptor;
+        public DataDirectory DelayImportDescriptor { get; set; }
 #else
-        public DataDirectory? DelayImportDescriptor;
+        public DataDirectory? DelayImportDescriptor { get; set; }
 #endif
 
         /// <summary>
         /// The CLR runtime header address and size.
         /// </summary>
 #if NET48
-        public DataDirectory CLRRuntimeHeader;
+        public DataDirectory CLRRuntimeHeader { get; set; }
 #else
-        public DataDirectory? CLRRuntimeHeader;
+        public DataDirectory? CLRRuntimeHeader { get; set; }
 #endif
 
         /// <summary>
         /// Reserved, must be zero
         /// </summary>
-        public ulong Reserved;
+        public ulong Reserved { get; set; }
 
         #endregion
     }