C# IWriter.WriteBlock方法代码示例

 /// <summary>
 /// Applies a set of data changes to a stream.
 /// </summary>
 /// <param name="changes">The data changes to apply.</param>
 /// <param name="baseOffset">The offset of the start of the area where the changes should be applied.</param>
 /// <param name="writer">The stream to write changes to.</param>
 public static void PatchData(IEnumerable<DataChange> changes, uint baseOffset, IWriter writer)
 {
     foreach (var change in changes)
     {
         writer.SeekTo(baseOffset + change.Offset);
         writer.WriteBlock(change.Data);
     }
 }

 public static void Copy(IReader input, IWriter output)
 {
     // http://stackoverflow.com/questions/230128/best-way-to-copy-between-two-stream-instances-c-sharp
     const int BufferSize = 0x1000;
     byte[] buffer = new byte[BufferSize];
     int read;
     while ((read = input.ReadBlock(buffer, 0, BufferSize)) > 0)
         output.WriteBlock(buffer, 0, read);
 }

 private static void WriteByteArray(byte[] data, IWriter writer)
 {
     if (data != null)
     {
         writer.WriteInt32(data.Length);
         writer.WriteBlock(data);
     }
     else
     {
         writer.WriteInt32(0);
     }
 }

        private static void WriteBlfInfo(Patch patch, IWriter writer)
        {
            if (patch.CustomBlfContent == null)
                return;

            var startPos = WriteBlockHeader(writer, AssemblyPatchBlockID.Blfc);
            writer.WriteByte(0); // Version 0

            writer.WriteByte((byte)patch.CustomBlfContent.TargetGame);

            // Write mapinfo filename
            if (patch.CustomBlfContent.MapInfoFileName != null)
                writer.WriteAscii(patch.CustomBlfContent.MapInfoFileName);
            else
                writer.WriteByte(0);

            // Write mapinfo data
            if (patch.CustomBlfContent.MapInfo != null)
            {
                writer.WriteUInt32((uint)patch.CustomBlfContent.MapInfo.Length);
                writer.WriteBlock(patch.CustomBlfContent.MapInfo);
            }
            else
            {
                writer.WriteUInt32(0);
            }

            // Write BLF containers
            writer.WriteInt16((short)patch.CustomBlfContent.BlfContainerEntries.Count);
            foreach (var blfContainerEntry in patch.CustomBlfContent.BlfContainerEntries)
            {
                writer.WriteAscii(blfContainerEntry.FileName);
                writer.WriteUInt32((uint)blfContainerEntry.BlfContainer.Length);
                writer.WriteBlock(blfContainerEntry.BlfContainer);
            }

            EndBlock(writer, startPos);
        }

        private static void WriteBlfInfo(Patch patch, ContainerWriter container, IWriter writer)
        {
            if (patch.CustomBlfContent == null)
                return;

            container.StartBlock("blfc", 0); // Version 0

            writer.WriteByte((byte) patch.CustomBlfContent.TargetGame);

            // Write mapinfo filename
            if (patch.CustomBlfContent.MapInfoFileName != null)
                writer.WriteAscii(patch.CustomBlfContent.MapInfoFileName);
            else
                writer.WriteByte(0);

            // Write mapinfo data
            if (patch.CustomBlfContent.MapInfo != null)
            {
                writer.WriteUInt32((uint) patch.CustomBlfContent.MapInfo.Length);
                writer.WriteBlock(patch.CustomBlfContent.MapInfo);
            }
            else
            {
                writer.WriteUInt32(0);
            }

            // Write BLF containers
            writer.WriteInt16((short) patch.CustomBlfContent.BlfContainerEntries.Count);
            foreach (BlfContainerEntry blfContainerEntry in patch.CustomBlfContent.BlfContainerEntries)
            {
                writer.WriteAscii(blfContainerEntry.FileName);
                writer.WriteUInt32((uint) blfContainerEntry.BlfContainer.Length);
                writer.WriteBlock(blfContainerEntry.BlfContainer);
            }

            container.EndBlock();
        }

        private static void WriteDataChanges(IList<DataChange> changes, IWriter writer)
        {
            List<DataChange> fourByteChanges = changes.Where(c => c.Data.Length == 4).ToList();
            List<DataChange> otherChanges = changes.Where(c => c.Data.Length != 4).ToList();

            // Write 4-byte changes
            writer.WriteUInt32((uint) fourByteChanges.Count);
            foreach (DataChange change in fourByteChanges)
            {
                writer.WriteUInt32(change.Offset);
                writer.WriteBlock(change.Data);
            }

            // Write other changes
            writer.WriteUInt32((uint) otherChanges.Count);
            foreach (DataChange change in otherChanges)
            {
                writer.WriteUInt32(change.Offset);
                writer.WriteInt32(change.Data.Length);
                writer.WriteBlock(change.Data);
            }
        }

		private static void WritePatchInfo(Patch patch, ContainerWriter container, IWriter writer)
		{
			container.StartBlock("titl", 2); // Version 2

			// Write target map info
			writer.WriteInt32(patch.MapID);
			if (patch.MapInternalName != null)
				writer.WriteAscii(patch.MapInternalName);
			else
				writer.WriteByte(0);

			// Write patch info
			writer.WriteUTF16(patch.Name);
			writer.WriteUTF16(patch.Description);
			writer.WriteUTF16(patch.Author);

			// Write screenshot
			if (patch.Screenshot != null)
			{
				writer.WriteInt32(patch.Screenshot.Length);
				writer.WriteBlock(patch.Screenshot);
			}
			else
			{
				writer.WriteInt32(0);
			}

			// Write meta info
			writer.WriteUInt32(patch.MetaPokeBase);
			writer.WriteSByte((sbyte) patch.MetaChangesIndex);

			// Write output name
			if (patch.OutputName != null)
				writer.WriteAscii(patch.OutputName);
			else
				writer.WriteByte(0);

			container.EndBlock();
		}

		private static void WriteMetaChanges(Patch patch, ContainerWriter container, IWriter writer)
		{
			if (patch.MetaChanges.Count == 0)
				return;

			container.StartBlock("meta", 0); // Version 0

			List<DataChange> fourByteChanges = patch.MetaChanges.Where(c => c.Data.Length == 4).ToList();
			List<DataChange> otherChanges = patch.MetaChanges.Where(c => c.Data.Length != 4).ToList();

			// Write 4-byte changes
			writer.WriteUInt32((uint) fourByteChanges.Count);
			foreach (DataChange change in fourByteChanges)
			{
				writer.WriteUInt32(change.Offset);
				writer.WriteBlock(change.Data);
			}

			// Write other changes
			writer.WriteUInt32((uint) otherChanges.Count);
			foreach (DataChange change in otherChanges)
			{
				writer.WriteUInt32(change.Offset);
				writer.WriteInt32(change.Data.Length);
				writer.WriteBlock(change.Data);
			}

			container.EndBlock();
		}

		/// <summary>
		///     Writes a meta change back to a cache file.
		/// </summary>
		/// <param name="cacheFile">The cache file to write the change to.</param>
		/// <param name="change">The change to write.</param>
		/// <param name="output">The stream to write the change to.</param>
		public static void WriteChange(ICacheFile cacheFile, DataChange change, IWriter output)
		{
			output.SeekTo(cacheFile.MetaArea.PointerToOffset(change.Offset));
			output.WriteBlock(change.Data);
		}

		private static void WriteDataBlocks(TagContainer tags, ContainerWriter container, IWriter writer)
		{
			foreach (DataBlock dataBlock in tags.DataBlocks)
			{
				container.StartBlock("data", 6);

				// Main data
				writer.WriteUInt32(dataBlock.OriginalAddress);
				writer.WriteInt32(dataBlock.EntryCount);
				writer.WriteInt32(dataBlock.Alignment);
				WriteByteArray(dataBlock.Data, writer);

				// Address fixups
				writer.WriteInt32(dataBlock.AddressFixups.Count);
				foreach (DataBlockAddressFixup blockRef in dataBlock.AddressFixups)
				{
					writer.WriteUInt32(blockRef.OriginalAddress);
					writer.WriteInt32(blockRef.WriteOffset);
				}

				// Tagref fixups
				writer.WriteInt32(dataBlock.TagFixups.Count);
				foreach (DataBlockTagFixup tagRef in dataBlock.TagFixups)
				{
					writer.WriteUInt32(tagRef.OriginalIndex.Value);
					writer.WriteInt32(tagRef.WriteOffset);
				}

				// Resource reference fixups
				writer.WriteInt32(dataBlock.ResourceFixups.Count);
				foreach (DataBlockResourceFixup resourceRef in dataBlock.ResourceFixups)
				{
					writer.WriteUInt32(resourceRef.OriginalIndex.Value);
					writer.WriteInt32(resourceRef.WriteOffset);
				}

				// StringID fixups
				writer.WriteInt32(dataBlock.StringIDFixups.Count);
				foreach (DataBlockStringIDFixup sid in dataBlock.StringIDFixups)
				{
					writer.WriteAscii(sid.OriginalString);
					writer.WriteInt32(sid.WriteOffset);
				}

				// Shader fixups
				writer.WriteInt32(dataBlock.ShaderFixups.Count);
				foreach (DataBlockShaderFixup shaderRef in dataBlock.ShaderFixups)
				{
					writer.WriteInt32(shaderRef.WriteOffset);
					if (shaderRef.Data != null)
					{
						writer.WriteInt32(shaderRef.Data.Length);
						writer.WriteBlock(shaderRef.Data);
					}
					else
					{
						writer.WriteInt32(0);
					}
				}

				// Unicode string list fixups
				writer.WriteInt32(dataBlock.UnicListFixups.Count);
				foreach (DataBlockUnicListFixup unicList in dataBlock.UnicListFixups)
				{
					writer.WriteInt32(unicList.LanguageIndex);
					writer.WriteInt32(unicList.WriteOffset);
					writer.WriteInt32(unicList.Strings.Length);
					foreach (UnicListFixupString str in unicList.Strings)
					{
						writer.WriteAscii(str.StringID);
						writer.WriteUTF8(str.String);
					}
				}

				container.EndBlock();
			}
		}

        /// <summary>
        ///     Fills a section of a stream with a repeating byte.
        /// </summary>
        /// <param name="writer">The IWriter to fill a section of.</param>
        /// <param name="b">The byte to fill the section with.</param>
        /// <param name="size">The size of the section to fill.</param>
        public static void Fill(IWriter writer, byte b, int size)
        {
            if (size == 0)
                return;
            if (size < 0)
                throw new ArgumentException("The size of the data to insert must be >= 0");
            if (writer.Position == writer.Length)
                return;

            const int BufferSize = 0x1000;
            var buffer = new byte[BufferSize];
            long pos = writer.Position;
            long endPos = pos + size;

            // Fill the buffer
            if (b != 0)
            {
                for (int i = 0; i < buffer.Length; i++)
                    buffer[i] = b;
            }

            // Write it
            while (pos < endPos)
            {
                writer.WriteBlock(buffer, 0, (int) Math.Min(endPos - pos, BufferSize));
                pos += BufferSize;
            }
        }

        private static void WriteMetaChanges(Patch patch, IWriter writer)
        {
            if (patch.MetaChanges.Count == 0)
                return;

            long startPos = writer.Position;
            writer.WriteInt32(AssemblyPatchBlockID.Meta);
            writer.WriteUInt32(0); // Size filled in later
            writer.WriteByte(0); // Version 0

            // Filter meta changes by size (as a file size optimization)
            List<MetaChange> fourByteChanges = new List<MetaChange>();
            List<MetaChange> otherChanges = new List<MetaChange>();
            foreach (MetaChange change in patch.MetaChanges)
            {
                if (change.Data.Length == 4)
                    fourByteChanges.Add(change);
                else
                    otherChanges.Add(change);
            }

            // Write 4-byte changes
            writer.WriteUInt32((uint)fourByteChanges.Count);
            foreach (MetaChange change in fourByteChanges)
            {
                writer.WriteUInt32(change.Address);
                writer.WriteBlock(change.Data);
            }

            // Write other changes
            writer.WriteUInt32((uint)otherChanges.Count);
            foreach (MetaChange change in otherChanges)
            {
                writer.WriteUInt32(change.Address);
                writer.WriteUInt32((uint)change.Data.Length);
                writer.WriteBlock(change.Data);
            }

            // Fill in the block size
            long endPos = writer.Position;
            writer.SeekTo(startPos + 4);
            writer.WriteUInt32((uint)(endPos - startPos));
            writer.SeekTo(endPos);
        }

        private static void WritePatchInfo(Patch patch, IWriter writer)
        {
            long startPos = writer.Position;
            writer.WriteInt32(AssemblyPatchBlockID.Titl);
            writer.WriteUInt32(0); // Size filled in later
            writer.WriteByte(0); // Version 0

            writer.WriteInt32(patch.MapID);
            if (patch.MapInternalName != null)
                writer.WriteAscii(patch.MapInternalName);
            else
                writer.WriteByte(0);
            writer.WriteUTF16(patch.Name);
            writer.WriteUTF16(patch.Description);
            writer.WriteUTF16(patch.Author);
            if (patch.Screenshot != null)
            {
                writer.WriteInt32(patch.Screenshot.Length);
                writer.WriteBlock(patch.Screenshot);
            }
            else
            {
                writer.WriteInt32(0);
            }

            // Fill in the block size
            long endPos = writer.Position;
            writer.SeekTo(startPos + 4);
            writer.WriteUInt32((uint)(endPos - startPos));
            writer.SeekTo(endPos);
        }

        private static void WritePatchInfo(Patch patch, IWriter writer)
        {
            var startPos = WriteBlockHeader(writer, AssemblyPatchBlockID.Titl);
            writer.WriteByte(1); // Version 1

            // Write target map info
            writer.WriteInt32(patch.MapID);
            if (patch.MapInternalName != null)
                writer.WriteAscii(patch.MapInternalName);
            else
                writer.WriteByte(0);

            // Write patch info
            writer.WriteUTF16(patch.Name);
            writer.WriteUTF16(patch.Description);
            writer.WriteUTF16(patch.Author);

            // Write screenshot
            if (patch.Screenshot != null)
            {
                writer.WriteInt32(patch.Screenshot.Length);
                writer.WriteBlock(patch.Screenshot);
            }
            else
            {
                writer.WriteInt32(0);
            }

            // Write meta info
            writer.WriteUInt32(patch.MetaPokeBase);
            writer.WriteSByte((sbyte)patch.MetaChangesIndex);

            EndBlock(writer, startPos);
        }

        private static void WriteMetaChanges(Patch patch, IWriter writer)
        {
            if (patch.MetaChanges.Count == 0)
                return;

            var startPos = WriteBlockHeader(writer, AssemblyPatchBlockID.Meta);
            writer.WriteByte(0); // Version 0

            var fourByteChanges = patch.MetaChanges.Where((c) => c.Data.Length == 4).ToList();
            var otherChanges = patch.MetaChanges.Where((c) => c.Data.Length != 4).ToList();

            // Write 4-byte changes
            writer.WriteUInt32((uint)fourByteChanges.Count);
            foreach (var change in fourByteChanges)
            {
                writer.WriteUInt32(change.Offset);
                writer.WriteBlock(change.Data);
            }

            // Write other changes
            writer.WriteUInt32((uint)otherChanges.Count);
            foreach (var change in otherChanges)
            {
                writer.WriteUInt32(change.Offset);
                writer.WriteInt32(change.Data.Length);
                writer.WriteBlock(change.Data);
            }

            EndBlock(writer, startPos);
        }