C# BinaryWriter.WriteZeros方法代码示例

 public void Write(Stream output)
 {
     BinaryWriter writer = new BinaryWriter(output, Encoding.Default, true);
     writer.Write(StringOffset);
     writer.WriteZeros(4);
     writer.Write(StringLength);
     writer.WriteZeros(4);
 }

        public void Write(Stream outputStream)
        {
            BinaryWriter writer = new BinaryWriter(outputStream, Encoding.Default, true);
            writer.Write(Encoding.Default.GetBytes(Signature));
            writer.Write(LittleEndianMagicNumber);
            writer.Write((byte) Entries.Count);
            writer.WriteZeros(1);
            writer.Write(FfntHeaderSize);
            writer.AlignWrite(16, 0x00);

            long entryHeaderPosition = outputStream.Position;

            outputStream.Position += Entries.Count*FfntEntryHeader.FfntEntryHeaderSize;
            writer.AlignWrite(16, 0x00);

            List<FfntEntryHeader> ffntEntryHeaders = new List<FfntEntryHeader>();

            foreach (var entry in Entries)
            {
                ffntEntryHeaders.Add(entry.GetHeader(outputStream));
                entry.Write(outputStream);
                writer.AlignWrite(16, 0x00);
            }

            outputStream.Position = entryHeaderPosition;

            foreach (var header in ffntEntryHeaders)
            {
                header.Write(outputStream);
            }
        }

		static void WriteAlign(BinaryWriter writer, ref uint offs) {
			uint align = Utils.AlignUp(offs, HH_ALIGNMENT) - offs;
			offs += align;
			writer.WriteZeros((int)align);
		}

        public void Serialize(uint token, uint key, byte[] fieldLayout)
        {
            using (var ms = new MemoryStream()) {
                var writer = new BinaryWriter(ms);
                foreach (byte i in fieldLayout)
                    switch (i) {
                        case 0:
                            writer.Write((uint)ILCode.Length);
                            break;
                        case 1:
                            writer.Write(MaxStack);
                            break;
                        case 2:
                            writer.Write((uint)EHs.Length);
                            break;
                        case 3:
                            writer.Write((uint)LocalVars.Length);
                            break;
                        case 4:
                            writer.Write(Options);
                            break;
                        case 5:
                            writer.Write(MulSeed);
                            break;
                    }

                writer.Write(ILCode);
                writer.Write(LocalVars);
                foreach (JITEHClause clause in EHs) {
                    writer.Write(clause.Flags);
                    writer.Write(clause.TryOffset);
                    writer.Write(clause.TryLength);
                    writer.Write(clause.HandlerOffset);
                    writer.Write(clause.HandlerLength);
                    writer.Write(clause.ClassTokenOrFilterOffset);
                }
                writer.WriteZeros(4 - ((int)ms.Length & 3)); // pad to 4 bytes
                Body = ms.ToArray();
            }
            Debug.Assert(Body.Length % 4 == 0);
            // encrypt body
            uint state = token * key;
            uint counter = state;
            for (uint i = 0; i < Body.Length; i += 4) {
                uint data = Body[i] | (uint)(Body[i + 1] << 8) | (uint)(Body[i + 2] << 16) | (uint)(Body[i + 3] << 24);
                Body[i + 0] ^= (byte)(state >> 0);
                Body[i + 1] ^= (byte)(state >> 8);
                Body[i + 2] ^= (byte)(state >> 16);
                Body[i + 3] ^= (byte)(state >> 24);
                state += data ^ counter;
                counter ^= (state >> 5) | (state << 27);
            }
        }

		/// <inheritdoc/>
		public void WriteTo(BinaryWriter writer) {
			RVA rva2 = rva;
			foreach (var resourceData in resources) {
				writer.Write(resourceData.GetFileLength());
				resourceData.VerifyWriteTo(writer);
				rva2 += 4 + resourceData.GetFileLength();
				int padding = (int)rva2.AlignUp(alignment) - (int)rva2;
				writer.WriteZeros(padding);
				rva2 += (uint)padding;
			}
		}

		/// <inheritdoc/>
		public void WriteTo(BinaryWriter writer) {
			WriteToImpl(writer);
			writer.WriteZeros((int)(Utils.AlignUp(GetRawLength(), ALIGNMENT) - GetRawLength()));
		}

		/// <inheritdoc/>
		public void WriteTo(BinaryWriter writer) {
			writer.Write(code);
			if (HasExtraSections) {
				RVA rva2 = rva + (uint)code.Length;
				writer.WriteZeros((int)rva2.AlignUp(EXTRA_SECTIONS_ALIGNMENT) - (int)rva2);
				writer.Write(extraSections);
			}
		}

 public void Write(Stream output)
 {
     BinaryWriter writer = new BinaryWriter(output, Encoding.Default, true);
     writer.Write(DataOffset);
     writer.WriteZeros(4);
     writer.Write(DataSize);
     writer.WriteZeros(4);
     FilePathFpkString.Write(output);
     writer.Write(Md5Hash);
 }

		/// <inheritdoc/>
		public void WriteTo(BinaryWriter writer) {
			uint offset = 0;

			// The order here must be the same as in SetOffset()

			foreach (var dir in dirList) {
				uint padding = Utils.AlignUp(offset, RESOURCE_DIR_ALIGNMENT) - offset;
				writer.WriteZeros((int)padding);
				offset += padding;
				if (dirDict[dir] != offset)
					throw new ModuleWriterException("Invalid Win32 resource directory offset");
				offset += WriteTo(writer, dir);
			}

			foreach (var dataHeader in dataHeaderList) {
				uint padding = Utils.AlignUp(offset, RESOURCE_DATA_HEADER_ALIGNMENT) - offset;
				writer.WriteZeros((int)padding);
				offset += padding;
				if (dataHeaderDict[dataHeader] != offset)
					throw new ModuleWriterException("Invalid Win32 resource data header offset");
				offset += WriteTo(writer, dataHeader);
			}

			foreach (var s in stringsList) {
				uint padding = Utils.AlignUp(offset, RESOURCE_STRING_ALIGNMENT) - offset;
				writer.WriteZeros((int)padding);
				offset += padding;
				if (stringsDict[s] != offset)
					throw new ModuleWriterException("Invalid Win32 resource string offset");

				var bytes = Encoding.Unicode.GetBytes(s);
				if (bytes.Length / 2 > ushort.MaxValue)
					throw new ModuleWriterException("Win32 resource entry name is too long");
				writer.Write((ushort)(bytes.Length / 2));
				writer.Write(bytes);
				offset += 2 + (uint)bytes.Length;
			}

			byte[] dataBuffer = new byte[0x2000];
			foreach (var data in dataList) {
				uint padding = Utils.AlignUp(offset, RESOURCE_DATA_ALIGNMENT) - offset;
				writer.WriteZeros((int)padding);
				offset += padding;
				if (dataDict[data] != offset)
					throw new ModuleWriterException("Invalid Win32 resource data offset");

				data.Position = 0;
				offset += data.WriteTo(writer, dataBuffer);
			}

			writer.WriteZeros((int)(Utils.AlignUp(length, ModuleWriterBase.DEFAULT_WIN32_RESOURCES_ALIGNMENT) - length));
		}

		/// <inheritdoc/>
		public void WriteTo(BinaryWriter writer) {
			writer.Write(options.Signature ?? MetaDataHeaderOptions.DEFAULT_SIGNATURE);
			writer.Write(options.MajorVersion ?? 1);
			writer.Write(options.MinorVersion ?? 1);
			writer.Write(options.Reserved1 ?? 0);
			var s = GetVersionString();
			writer.Write(Utils.AlignUp(s.Length, 4));
			writer.Write(s);
			writer.WriteZeros(Utils.AlignUp(s.Length, 4) - s.Length);
			writer.Write((byte)(options.StorageFlags ?? 0));
			writer.Write(options.Reserved2 ?? 0);
			writer.Write((ushort)heaps.Count);
			foreach (var heap in heaps) {
				writer.Write((uint)(heap.FileOffset - offset));
				writer.Write(heap.GetFileLength());
				writer.Write(s = GetAsciizName(heap.Name));
				if (s.Length > 32)
					throw new ModuleWriterException(string.Format("Heap name '{0}' is > 32 bytes", heap.Name));
				writer.WriteZeros(Utils.AlignUp(s.Length, 4) - s.Length);
			}
		}

		/// <inheritdoc/>
		public void WriteTo(BinaryWriter writer) {
			writer.Write((uint)importLookupTableRVA);
			writer.Write(0);	// DateTimeStamp
			writer.Write(0);	// ForwarderChain
			writer.Write((uint)mscoreeDllRVA);	// Name
			writer.Write((uint)ImportAddressTable.RVA);
			writer.Write(0UL);
			writer.Write(0UL);
			writer.Write(0);

			// ImportLookupTable
			writer.Write((uint)corXxxMainRVA);
			writer.Write(0);

			writer.WriteZeros(stringsPadding);
			writer.Write((ushort)0);
			writer.Write(Encoding.UTF8.GetBytes(IsExeFile ? "_CorExeMain\0" : "_CorDllMain\0"));
			writer.Write(Encoding.UTF8.GetBytes("mscoree.dll\0"));

			writer.Write((byte)0);
		}

		/// <summary>
		/// Writes the full table to the hot table
		/// </summary>
		/// <param name="writer">Writer</param>
		void FullWriteTo(BinaryWriter writer) {
			CreateFullData();

			var startPos = writer.BaseStream.Position;
			writer.Write(mdTable.Rows);	// hot records
			writer.Write(0);			// offset of 1st level table
			writer.Write(0);			// offset of 2nd level table
			if (version == HotHeapVersion.CLR40)
				writer.Write(0);		// offset of indexes table
			writer.Write(alignedHotTableHeaderSize);	// offset of hot data (4-byte aligned)
			writer.Write((ushort)0);	// shift count
			writer.WriteZeros(alignedHotTableHeaderSize - (int)(writer.BaseStream.Position - startPos));
			writer.Write(data);
		}

		/// <inheritdoc/>
		internal override void PartialWriteTo(BinaryWriter writer) {
			var startPos = writer.BaseStream.Position;
			writer.Write(partialData.Count);// hot records
			writer.Write(firstLevelOffset);	// any alignment, all bits are used
			writer.Write(secondLevelOffset);// any alignment, all bits are used
			writer.Write(indexesOffset);// any alignment, all bits are used
			writer.Write(dataOffset);	// any alignment, all bits are used
			writer.Write((ushort)shift);// shift count
			writer.WriteZeros(alignedHotTableHeaderSize - (int)(writer.BaseStream.Position - startPos));

			uint offs;

			// Data
			offs = (uint)(writer.BaseStream.Position - startPos);
			writer.WriteZeros((int)(dataOffset - offs));
			WritePartialData(writer);

			// First level table
			offs = (uint)(writer.BaseStream.Position - startPos);
			writer.WriteZeros((int)(firstLevelOffset - offs));
			WriteFirstLevelTable(writer);

			// Second level table
			offs = (uint)(writer.BaseStream.Position - startPos);
			writer.WriteZeros((int)(secondLevelOffset - offs));
			WriteSecondLevelTable(writer);

			// Indexes table
			offs = (uint)(writer.BaseStream.Position - startPos);
			writer.WriteZeros((int)(indexesOffset - offs));
			WriteIndexesTable(writer);
		}

		/// <inheritdoc/>
		public void WriteTo(BinaryWriter writer) {
			writer.WriteZeros((int)padding);
			writer.Write((byte)0xFF);
			writer.Write((byte)0x25);
			writer.Write((uint)PEHeaders.ImageBase + (uint)ImportDirectory.IatCorXxxMainRVA);
		}

        public override void Write(Stream output, IDirectory inputDirectory)
        {
            BinaryWriter writer = new BinaryWriter(output, Encoding.Default, true);
            const int headerSize = 48;
            int indicesSize = 48*Entries.Count;
            int referenceSize = 16*References.Count;

            long startPosition = output.Position;
            output.Position += headerSize + indicesSize + referenceSize;

            foreach (var fpkEntry in Entries)
            {
                fpkEntry.WriteFilePath(output);
            }
            foreach (var fpkReference in References)
            {
                fpkReference.WriteFilePath(output);
            }
            output.AlignWrite(16, 0x00);

            foreach (var fpkEntry in Entries)
            {
                fpkEntry.WriteData(output, inputDirectory);
                output.AlignWrite(16, 0x00);
            }

            uint fileSize = (uint) output.Position;

            output.Position = startPosition;

            writer.Write(0x66786f66); // foxf
            writer.Write((ushort) 0x6B70); //pk
            writer.Write((byte) FpkType);
            writer.Write((byte) 0x77); // w
            writer.Write((ushort) 0x6E69); // in
            writer.Write(fileSize);
            writer.WriteZeros(18);
            writer.Write(0x00000002);
            writer.Write(Entries.Count);
            writer.Write(References.Count);
            writer.WriteZeros(4);

            foreach (var fpkEntry in Entries)
            {
                fpkEntry.Write(output);
            }
            foreach (var fpkReference in References)
            {
                fpkReference.Write(output);
            }
        }