public class ByteArrayBuilder : IDisposable
{
#region Constants
/// <summary>
/// True in a byte form of the Line
/// </summary>
const byte streamTrue = (byte)1;
/// <summary>
/// False in the byte form of a line
/// </summary>
const byte streamFalse = (byte)0;
#endregion #region Fields
#region Internal
/// <summary>
/// Holds the actual bytes.
/// </summary>
MemoryStream store = new MemoryStream(); /// <summary>
/// Is Little Endian
/// True - little endian
/// False - big endian
/// </summary>
bool isLittleEndian;
#endregion #region Property bases
#endregion
#endregion #region Properties
/// <summary>
/// Bytes in the store.
/// </summary>
public int Length
{
get { return (int)store.Length; }
}
#endregion #region Regular Expressions
#endregion #region Enums
#endregion #region Constructors
/// <summary>
/// Create a new, empty builder ready to be filled.
/// </summary>
public ByteArrayBuilder(bool isLittleEndian = true)
{
this.isLittleEndian = isLittleEndian;
}
/// <summary>
/// Create a new builder from a set of data
/// </summary>
/// <param name="data">Data to preset the builder from</param>
public ByteArrayBuilder(byte[] data, bool isLittleEndian = true)
{
store.Close();
store.Dispose();
store = new MemoryStream(data);
this.isLittleEndian = isLittleEndian;
}
/// <summary>
/// Create a new builder from the Base64 string representation of an
/// existing instance.
/// The Base64 representation can be retrieved using the ToString override
/// </summary>
/// <param name="base64">Base64 string representation of an
/// existing instance.</param>
public ByteArrayBuilder(string base64, bool isLittleEndian = true)
{
store.Close();
store.Dispose();
store = new MemoryStream(Convert.FromBase64String(base64));
this.isLittleEndian = isLittleEndian;
}
#endregion #region Events
#region Event Constructors
#endregion #region Event Handlers
#endregion
#endregion #region Public Methods
#region Append overloads
/// <summary>
/// Adds a bool to an array
/// </summary>
/// <param name="b">Value to append to existing builder data</param>
public void Append(bool b)
{
store.WriteByte(b ? streamTrue : streamFalse);
}
/// <summary>
/// Adds a byte to an array
/// </summary>
/// <param name="b">Value to append to existing builder data</param>
public void Append(byte b)
{
store.WriteByte(b);
}
/// <summary>
/// Adds an array of bytes to an array
/// </summary>
/// <param name="b">Value to append to existing builder data</param>
/// <param name="addLength">
/// If true, the length is added before the value.
/// This allows extraction of individual elements back to the original input form.
/// </param>
public void Append(byte[] b, bool addLength = false)
{
if (b != null)
{
if (addLength) Append(b.Length);
AddBytes(b);
}
}
/// <summary>
/// Adds a char to an array
/// </summary>
/// <param name="c">Value to append to existing builder data</param>
public void Append(char c)
{
store.WriteByte((byte)c);
}
/// <summary>
/// Adds an array of characters to an array
/// </summary>
/// <param name="c">Value to append to existing builder data</param>
/// <param name="addLength">
/// If true, the length is added before the value.
/// This allows extraction of individual elements back to the original input form.
/// </param>
public void Append(char[] c, bool addLength = false)
{
if (c != null)
{
if (addLength) Append(c.Length);
Append(System.Text.Encoding.Unicode.GetBytes(c));
}
}
/// <summary>
/// Adds a DateTime to an array
/// </summary>
/// <param name="dt">Value to append to existing builder data</param>
public void Append(DateTime dt)
{
Append(dt.Ticks);
}
/// <summary>
/// Adds a decimal value to an array
/// </summary>
/// <param name="d">Value to append to existing builder data</param>
public void Append(decimal d)
{
// GetBits always returns four ints.
// We store them in a specific order so that they can be recovered later.
int[] bits = decimal.GetBits(d); if (isLittleEndian)
{
Append(bits[0]);
Append(bits[1]);
Append(bits[2]);
Append(bits[3]);
}
else
{
Append(bits[3]);
Append(bits[2]);
Append(bits[1]);
Append(bits[0]);
}
}
/// <summary>
/// Adds a double to an array
/// </summary>
/// <param name="d">Value to append to existing builder data</param>
public void Append(double d)
{
byte[] data = BitConverter.GetBytes(d);
if (!isLittleEndian)
{
Array.Reverse(data);
} AddBytes(data);
}
/// <summary>
/// Adds a float to an array
/// </summary>
/// <param name="f">Value to append to existing builder data</param>
public void Append(float f)
{
byte[] data = BitConverter.GetBytes(f);
if (!isLittleEndian)
{
Array.Reverse(data);
} AddBytes(data);
}
/// <summary>
/// Adds a Guid to an array
/// </summary>
/// <param name="g">Value to append to existing builder data</param>
public void Append(Guid g)
{
Append(g.ToByteArray());
}
/// <summary>
/// Adds an integer to an array
/// </summary>
/// <param name="i">Value to append to existing builder data</param>
public void Append(int i)
{
byte[] data = BitConverter.GetBytes(i);
if (!isLittleEndian)
{
Array.Reverse(data);
} AddBytes(data);
}
/// <summary>
/// Adds a long integer to an array
/// </summary>
/// <param name="l">Value to append to existing builder data</param>
public void Append(long l)
{
byte[] data = BitConverter.GetBytes(l);
if (!isLittleEndian)
{
Array.Reverse(data);
} AddBytes(data);
}
/// <summary>
/// Adds a short integer to an array
/// </summary>
/// <param name="i">Value to append to existing builder data</param>
public void Append(short s)
{
byte[] data = BitConverter.GetBytes(s);
if (!isLittleEndian)
{
Array.Reverse(data);
} AddBytes(data);
}
/// <summary>
/// Adds a string to an array
/// </summary>
/// <param name="s">Value to append to existing builder data</param>
/// <param name="addLength">
/// If true, the length is added before the value.
/// This allows extraction of individual elements back to the original input form.
/// </param>
public void Append(string s, bool addLength = false)
{
if (!string.IsNullOrEmpty(s))
{
byte[] data = System.Text.Encoding.Unicode.GetBytes(s);
if (addLength) Append(data.Length);
AddBytes(data);
}
}
/// <summary>
/// Adds an unsigned integer to an array
/// </summary>
/// <param name="ui">Value to append to existing builder data</param>
public void Append(uint ui)
{
byte[] data = BitConverter.GetBytes(ui);
if (!isLittleEndian)
{
Array.Reverse(data);
} AddBytes(data);
}
/// <summary>
/// Adds a unsigned long integer to an array
/// </summary>
/// <param name="ul">Value to append to existing builder data</param>
public void Append(ulong ul)
{
byte[] data = BitConverter.GetBytes(ul);
if (!isLittleEndian)
{
Array.Reverse(data);
} AddBytes(data);
}
/// <summary>
/// Adds a unsigned short integer to an array
/// </summary>
/// <param name="us">Value to append to existing builder data</param>
public void Append(ushort us)
{
byte[] data = BitConverter.GetBytes(us);
if (!isLittleEndian)
{
Array.Reverse(data);
} AddBytes(data);
}
#endregion #region Extraction
/// <summary>
/// Gets a bool from an array
/// </summary>
/// <returns></returns>
public bool GetBool()
{
return store.ReadByte() == streamTrue;
}
/// <summary>
/// Gets a byte from an array
/// </summary>
/// <returns></returns>
public byte GetByte()
{
return (byte)store.ReadByte();
}
/// <summary>
/// Gets an array of bytes from an array
/// </summary>
/// <returns></returns>
public byte[] GetByteArray()
{
int length = GetInt();
return GetBytes(length);
}
/// <summary>
/// Gets a char from an array
/// </summary>
/// <returns></returns>
public char GetChar()
{
return (char)store.ReadByte();
}
/// <summary>
/// Gets an array of characters from an array
/// </summary>
/// <returns></returns>
public char[] GetCharArray()
{
int length = GetInt();
return System.Text.Encoding.Unicode.GetChars(GetBytes(length));
}
/// <summary>
/// Gets a DateTime value from an array
/// </summary>
/// <returns></returns>
public DateTime GetDateTime()
{
return new DateTime(GetLong());
}
/// <summary>
/// Gets a decimal value from an array
/// </summary>
/// <returns></returns>
public decimal GetDecimal()
{
// GetBits always returns four ints.
// We store them in a specific order so that they can be recovered later.
int[] bits = new int[] { GetInt(), GetInt(), GetInt(), GetInt() };
if(!isLittleEndian)
{
Array.Reverse(bits);
}
return new decimal(bits);
}
/// <summary>
/// Gets a double from an array
/// </summary>
/// <returns></returns>
public double GetDouble()
{
byte[] data = GetBytes(8);
if (!isLittleEndian)
{
Array.Reverse(data);
}
return BitConverter.ToDouble(data, 0);
}
/// <summary>
/// Gets a float from an array
/// </summary>
/// <returns></returns>
public float GetFloat()
{
byte[] data = GetBytes(4);
if (!isLittleEndian)
{
Array.Reverse(data);
}
return BitConverter.ToSingle(data, 0);
}
/// <summary>
/// Gets a Guid from an array
/// </summary>
/// <returns></returns>
public Guid GetGuid()
{
return new Guid(GetByteArray());
}
/// <summary>
/// Gets an integer from an array
/// </summary>
/// <returns></returns>
public int GetInt()
{
byte[] data = GetBytes(4);
if (!isLittleEndian)
{
Array.Reverse(data);
}
return BitConverter.ToInt32(data, 0);
}
/// <summary>
/// Gets a long integer from an array
/// </summary>
/// <returns></returns>
public long GetLong()
{
byte[] data = GetBytes(8);
if (!isLittleEndian)
{
Array.Reverse(data);
}
return BitConverter.ToInt64(data, 0);
}
/// <summary>
/// Gets a short integer from an array
/// </summary>
/// <returns></returns>
public short GetShort()
{
byte[] data = GetBytes(2);
if (!isLittleEndian)
{
Array.Reverse(data);
}
return BitConverter.ToInt16(data, 0);
}
/// <summary>
/// Gets a string from an array
/// </summary>
/// <returns></returns>
public string GetString()
{
int length = GetInt();
return System.Text.Encoding.Unicode.GetString(GetBytes(length));
}
/// <summary>
/// Gets an unsigned integer from an array
/// </summary>
/// <returns></returns>
public uint GetUint()
{
byte[] data = GetBytes(4);
if (!isLittleEndian)
{
Array.Reverse(data);
}
return BitConverter.ToUInt32(data, 0);
}
/// <summary>
/// Gets a unsigned long integer from an array
/// </summary>
/// <returns></returns>
public ulong GetUlong()
{
byte[] data = GetBytes(8);
if (!isLittleEndian)
{
Array.Reverse(data);
}
return BitConverter.ToUInt64(data, 0);
}
/// <summary>
/// Gets a unsigned short integer from an array
/// </summary>
/// <returns></returns>
public ushort GetUshort()
{
byte[] data = GetBytes(2);
if (!isLittleEndian)
{
Array.Reverse(data);
}
return BitConverter.ToUInt16(data, 0);
}
#endregion #region Interaction
/// <summary>
/// Clear all content from the builder
/// </summary>
public void Clear()
{
store.Close();
store.Dispose();
store = new MemoryStream();
}
/// <summary>
/// Rewind the builder ready to read data
/// </summary>
public void Rewind()
{
store.Seek(0, SeekOrigin.Begin);
}
/// <summary>
/// Set an absolute position in the builder.
/// **WARNING**
/// If you add any variable size objects to the builder, the results of
/// reading after a Seek to a non-zero value are unpredictable.
/// A builder does not store just objects - for some it stores additional
/// information as well.
/// </summary>
/// <param name="position"></param>
public void Seek(int position)
{
store.Seek((long)position, SeekOrigin.Begin);
}
/// <summary>
/// Returns the builder as an array of bytes
/// </summary>
/// <returns></returns>
public byte[] ToArray()
{
byte[] data = new byte[Length];
Array.Copy(store.GetBuffer(), data, Length);
return data;
}
#endregion
#endregion #region Overrides
/// <summary>
/// Returns a text based (Base64) string version of the current content
/// </summary>
/// <returns></returns>
public override string ToString()
{
return Convert.ToBase64String(ToArray());
}
#endregion #region Private Methods
/// <summary>
/// Add a string of raw bytes to the store
/// </summary>
/// <param name="b"></param>
private void AddBytes(byte[] b)
{
if (b != null)
{
store.Write(b, 0, b.Length);
}
}
/// <summary>
/// Reads a specific number of bytes from the store
/// </summary>
/// <param name="length"></param>
/// <returns></returns>
private byte[] GetBytes(int length)
{
byte[] data = new byte[length];
if (length > 0)
{
int read = store.Read(data, 0, length);
if (read != length)
{
throw new ApplicationException("Buffer did not contain " + length + " bytes");
}
}
return data;
}
#endregion #region IDisposable Implememntation
/// <summary>
/// Dispose of this builder and it's resources
/// </summary>
public void Dispose()
{
store.Close();
store.Dispose();
}
#endregion
}