Moving data inside the MemoryStream

[Airslash]

Hello,

I'm currently working with a MemoryStream, because I need to work with a dynamic buffer that can grow depending on the needs. But I require it to be more flexible that the standard defines.

For example, I want to be able to delete a portion of the buffer and move the data behind the deleted part upwards, sort of like in a List.

To perform a delete on the "buffer", I wrote the following function. Anyone tried this before?

/// <summary>
        /// Deletes a specific portion of the MemoryBuffer, effectively erasing
        /// the data in that section and moving the data behind the deleted part
        /// upwards in the buffer.
        /// </summary>
        /// <param name="position">The first position of where to start deleting data.</param>
        /// <param name="length">The amount of bytes to delete from the MemoryBuffer.</param>
        public void Delete(int position, int length)
        {
            // Obtain a lock first on the MemoryStream for exclusive access.
            lock (m_lock)
            {
                // First check if the range we wish to delete falls withing the
                // valid working space. This means that the sum of the position
                // and length cannot surpass our length.
                if ((position + length) > Length)
                    throw new InvalidOperationException("Specified range falls outside the range of the MemoryBuffer.");
 
                // We have verified that the selection we wish to delete falls in the
                // range of the MemoryBuffer. Now we need to extract the data first that
                // has to be moved.
                int data_length = Length - (position + length);
 
                m_stream.Seek(position, SeekOrigin.Begin);
                m_stream.Write(m_stream.GetBuffer(), (position + length), data_length);
 
                /*
                byte[] data = new byte[data_length];
 
                // Position the memorystream to the offset specified by the user.
                m_stream.Seek(position + length, SeekOrigin.Begin);
 
                // Read out the data we need to move.
                m_stream.Read(data, 0, data_length);
 
                // Change the length of our class, since this will be shortened by
                // the deleted part.
                Length -= length;
 
                // Write the data at the position we supposedly have deleted.
                m_stream.Seek(position, SeekOrigin.Begin);
                m_stream.Write(data, 0, data_length);
                */
            }
        }
 

[Plater]

Could you use a List<byte> ?

Also does your function work? Looking briefly it looks like it was doing things backwards?

I left out all the error checking, but you get the idea:

private static void DeleteFromMS(ref MemoryStream ms, int position, int length)
{
  int BeginingSectionLength = (int)(position);
  int EndingSectionLength = (int)(ms.Length - (position + length));
 
  byte[] AllGood = new byte[BeginingSectionLength + EndingSectionLength];
  ms.Seek(0, SeekOrigin.Begin);//rewind!
  ms.Read(AllGood, 0, BeginingSectionLength);
  ms.Seek(length, SeekOrigin.Current);//move over the unwanted data
  ms.Read(AllGood, BeginingSectionLength, EndingSectionLength);
  ms.Close();
  ms.Dispose();
  ms = new MemoryStream(AllGood);
}
 

Although to be honest, using a MemoryStream seems like a waste (unless you HAVE to use a derivative of the Stream class)
Seems like a byte[](Or List<byte>.ToArray() ) with Array.Copy() would be just as good

[Airslash]

will give it a spin on monday.
Just looking for a means to do it as effective as possible without getting to much copies & new statements that take the performance down.

Might give it a go with a List and see what it does.