[Experiment5X]

Hi, I was wondering how I could add bytes to a file. For example I want to add let's say 16 bytes to the file at the offset 0x20. I don't want to write over existing ones, I need to add them to the file so it will be larger. Any help would be appreciated, thanks.

[Retrix]

What kind of file?
be more elaborate

[Experiment5X]

Originally Posted by Retrix

What kind of file?
be more elaborate

Any file.

This:


To this:

[Cheater912]

You can't really. You shouldn't have to either.

You have to make a new file or overwrite everything.

[Oscar]

If the file isn't to big you could probably just get away with reading the file into the memory from the offset to EOF, writing the bytes you want to insert then writing the end of the file after that.

var iostream = File.Open("file.bin", FileMode.Open);
byte[] buffer = new byte[iostream.Length - 0x20];

iostream.Seek(0x20, SeekOrigin.Begin);
iostream.Read(buffer, 0, buffer.Length);
iostream.Seek(0x20, SeekOrigin.Begin);
iostream.Write(new byte[16], 0, 16); //bytes to insert
iostream.Write(buffer, 0, buffer.Length);
iostream.Close();

It's still kinda improper, always best to look for an alternative way.

[Eaton]

        /// <summary>
        /// Inserts bytes into the given stream.
        /// </summary>
        /// <param name="Source">The stream to insert bytes into.</param>
        /// <param name="Offset">Position to insert bytes into.</param>
        /// <param name="Data">Bytes to insert.</param>
        public static byte[] InsertBytes(Stream Source, int Offset, byte[] Data)
        {
            using (var io = new EndianIO(Source, EndianType.LittleEndian))
            {
                io.Open();
                var firstArray = io.Reader.ReadBytes(Offset);
                var secondArray = io.Reader.ReadBytes((int)io.Stream.Length - (int)io.Position);
                var newArray = new byte[Source.Length + Data.Length];
                Buffer.BlockCopy(firstArray, 0, newArray, 0, firstArray.Length);
                Buffer.BlockCopy(Data, 0, newArray, firstArray.Length, Data.Length);
                Buffer.BlockCopy(secondArray, 0, newArray, firstArray.Length + Data.Length, secondArray.Length);
                return newArray;
            }
        }

        /// <summary>
        /// Inserts bytes into the given byte array.
        /// </summary>
        /// <param name="Source">The byte array to insert bytes into.</param>
        /// <param name="Offset">Position to insert bytes into.</param>
        /// <param name="Data">Bytes to insert.</param>
        public static byte[] InsertBytes(byte[] Source, int Offset, byte[] Data)
        {
            using (var io = new EndianIO(Source, EndianType.LittleEndian))
            {
                io.Open();
                var firstArray = io.Reader.ReadBytes(Offset);
                var secondArray = io.Reader.ReadBytes((int)io.Stream.Length - (int)io.Position);
                var newArray = new byte[Source.Length + Data.Length];
                Buffer.BlockCopy(firstArray, 0, newArray, 0, firstArray.Length);
                Buffer.BlockCopy(Data, 0, newArray, firstArray.Length, Data.Length);
                Buffer.BlockCopy(secondArray, 0, newArray, firstArray.Length + Data.Length, secondArray.Length);
                return newArray;
            }
        }

        /// <summary>
        /// Deletes bytes from the given stream.
        /// </summary>
        /// <param name="Source">The stream to delete bytes from.</param>
        /// <param name="Offset">Position to delete bytes from.</param>
        /// <param name="Size">How many bytes to delete.</param>
        public static byte[] DeleteBytes(Stream Source, int Offset, int Size)
        {
            using (var io = new EndianIO(Source, EndianType.LittleEndian))
            {
                io.Open();
                var firstArray = io.Reader.ReadBytes(Offset);
                io.SetPosition(Size, SeekOrigin.Current);
                var secondArray = io.Reader.ReadBytes((int)io.Stream.Length - (int)io.Position);
                var newArray = new byte[Source.Length - Size];
                Buffer.BlockCopy(firstArray, 0, newArray, 0, firstArray.Length);
                Buffer.BlockCopy(secondArray, 0, newArray, firstArray.Length, secondArray.Length);
                return newArray;
            }
        }

        /// <summary>
        /// Deletes bytes from the given byte array.
        /// </summary>
        /// <param name="Source">The byte array to delete bytes from.</param>
        /// <param name="Offset">Position to delete bytes from.</param>
        /// <param name="Size">How many bytes to delete.</param>
        public static byte[] DeleteBytes(byte[] Source, int Offset, int Size)
        {
            using (var io = new EndianIO(Source, EndianType.LittleEndian))
            {
                io.Open();
                var firstArray = io.Reader.ReadBytes(Offset);
                io.SetPosition(Size, SeekOrigin.Current);
                var secondArray = io.Reader.ReadBytes((int)io.Stream.Length - (int)io.Position);
                var newArray = new byte[Source.Length - Size];
                Buffer.BlockCopy(firstArray, 0, newArray, 0, firstArray.Length);
                Buffer.BlockCopy(secondArray, 0, newArray, firstArray.Length, secondArray.Length);
                return newArray;
            }
        }