public class GSWrappedObject
    {
        public object Data
        {
            get;
            private set;
        }

        public GSDataType Type
        {
            get;
            private set;
        }

        public GSWrappedObject()
        {
            this.Data = null;
            this.Type = GSDataType.Null;
        }

        /// <summary>
        /// Returns this object in the GS binary format.
        /// </summary>
        /// <returns></returns>
        public byte[] ToGSBinary()
        {
            List<byte> bytes = new List<byte>();

            switch (Type)
            {
                case GSDataType.Null:
                    bytes.Add((byte)GSDataType.Null);
                    break;
                case GSDataType.Bool:
                    bytes.Add((byte)GSDataType.Bool);
                    bytes.AddRange(AsBool().ToGSBinary());
                    break;
                case GSDataType.BoolArray:
                    bytes.Add((byte)GSDataType.ByteArray);
                    bytes.AddRange(AsByteArray().ToGSBinary());
                    break;
                case GSDataType.Byte:
                    bytes.Add((byte)GSDataType.Byte);
                    bytes.Add(AsByte());
                    break;
                case GSDataType.ByteArray:
                    bytes.Add((byte)GSDataType.ByteArray);
                    bytes.AddRange(AsByteArray().ToGSBinary());
                    break;
                case GSDataType.Short:
                    bytes.Add((byte)GSDataType.Short);
                    bytes.AddRange(AsShort().ToGSBinary());
                    break;
                case GSDataType.ShortArray:
                    bytes.Add((byte)GSDataType.ShortArray);
                    bytes.AddRange(AsShortArray().ToGSBinary());
                    break;
                case GSDataType.Int:
                    bytes.Add((byte)GSDataType.Int);
                    bytes.AddRange(AsInt().ToGSBinary());
                    break;
                case GSDataType.IntArray:
                    bytes.Add((byte)GSDataType.IntArray);
                    bytes.AddRange(AsIntArray().ToGSBinary());
                    break;
                case GSDataType.Long:
                    bytes.Add((byte)GSDataType.Long);
                    bytes.AddRange(AsLong().ToGSBinary());
                    break;
                case GSDataType.LongArray:
                    bytes.Add((byte)GSDataType.LongArray);
                    bytes.AddRange(AsLongArray().ToGSBinary());
                    break;
                case GSDataType.Float:
                    bytes.Add((byte)GSDataType.Float);
                    bytes.AddRange(AsFloat().ToGSBinary());
                    break;
                case GSDataType.FloatArray:
                    bytes.Add((byte)GSDataType.FloatArray);
                    bytes.AddRange(AsFloatArray().ToGSBinary());
                    break;
                case GSDataType.Double:
                    bytes.Add((byte)GSDataType.Double);
                    bytes.AddRange(AsDouble().ToGSBinary());
                    break;
                case GSDataType.DoubleArray:
                    bytes.Add((byte)GSDataType.DoubleArray);
                    bytes.AddRange(AsDoubleArray().ToGSBinary());
                    break;
                case GSDataType.String:
                    bytes.Add((byte)GSDataType.String);
                    bytes.AddRange(AsString().ToGSBinary());
                    break;
                case GSDataType.StringArray:
                    bytes.Add((byte)GSDataType.StringArray);
                    bytes.AddRange(AsStringArray().ToGSBinary());
                    break;
                case GSDataType.GSArray:
                    bytes.Add((byte)GSDataType.GSArray);
                    bytes.AddRange(AsGSArray().ToGSBinary());
                    break;
                case GSDataType.GSObject:
                    bytes.Add((byte)GSDataType.GSObject);
                    bytes.AddRange(AsGSObject().ToGSBinary());
                    break;
            }

            return bytes.ToArray();
        }

        public static implicit operator GSWrappedObject(bool value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.Bool };
        }

        public static implicit operator GSWrappedObject(byte value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.Byte };
        }

        public static implicit operator GSWrappedObject(short value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.Short };
        }

        public static implicit operator GSWrappedObject(int value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.Int };
        }

        public static implicit operator GSWrappedObject(long value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.Long };
        }

        public static implicit operator GSWrappedObject(float value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.Float };
        }

        public static implicit operator GSWrappedObject(double value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.Double };
        }

        public static implicit operator GSWrappedObject(string value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.String };
        }

        public static implicit operator GSWrappedObject(bool[] value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.BoolArray };
        }

        public static implicit operator GSWrappedObject(byte[] value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.ByteArray };
        }

        public static implicit operator GSWrappedObject(short[] value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.ShortArray };
        }

        public static implicit operator GSWrappedObject(int[] value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.IntArray };
        }

        public static implicit operator GSWrappedObject(long[] value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.LongArray };
        }

        public static implicit operator GSWrappedObject(float[] value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.FloatArray };
        }

        public static implicit operator GSWrappedObject(double[] value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.DoubleArray };
        }

        public static implicit operator GSWrappedObject(string[] value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.StringArray };
        }

        public static implicit operator GSWrappedObject(GSArray value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.GSArray };
        }

        public static implicit operator GSWrappedObject(GSObject value)
        {
            return new GSWrappedObject() { Data = value, Type = GSDataType.GSObject };
        }

        /// <summary>
        /// Determines whether the wrapped data is null.
        /// </summary>
        /// <returns></returns>
        public bool IsNull()
        {
            return Type == GSDataType.Null || Data == null;
        }

        #region Bool, BoolArray
        /// <summary>
        /// Gets the wrapped data as a boolean.
        /// </summary>
        /// <returns></returns>
        public bool AsBool()
        {
            return (bool)Data;
        }

        /// <summary>
        /// Gets the wrapped data as an array of booleans.
        /// </summary>
        /// <returns></returns>
        public bool[] AsBoolArray()
        {
            return (bool[])Data;
        }
        #endregion

        #region Byte, ByteArray
        /// <summary>
        /// Gets the wrapped data as an 8-bit integer.
        /// </summary>
        /// <returns></returns>
        public byte AsByte()
        {
            return (byte)Data;
        }

        /// <summary>
        /// Gets the wrapped data as an array of 8-bit integers.
        /// </summary>
        /// <returns></returns>
        public byte[] AsByteArray()
        {
            return (byte[])Data;
        }
        #endregion

        #region Short, ShortArray
        /// <summary>
        /// Gets the wrapped data as a 16-bit integer.
        /// </summary>
        /// <returns></returns>
        public short AsShort()
        {
            return (short)Data;
        }

        /// <summary>
        /// Gets the wrapped data as an array of 16-bit integers.
        /// </summary>
        /// <returns></returns>
        public short[] AsShortArray()
        {
            return (short[])Data;
        }
        #endregion

        #region Int, IntArray
        /// <summary>
        /// Gets the wrapped data as a 32-bit integer.
        /// </summary>
        /// <returns></returns>
        public int AsInt()
        {
            return (int)Data;
        }

        /// <summary>
        /// Gets the wrapped data as an array of 16-bit integers.
        /// </summary>
        /// <returns></returns>
        public int[] AsIntArray()
        {
            return (int[])Data;
        }
        #endregion

        #region Long, LongArray
        /// <summary>
        /// Gets the wrapped data as a 64-bit integer.
        /// </summary>
        /// <returns></returns>
        public long AsLong()
        {
            return (long)Data;
        }

        /// <summary>
        /// Gets the wrapped data as an array of 64-bit integers.
        /// </summary>
        /// <returns></returns>
        public long[] AsLongArray()
        {
            return (long[])Data;
        }
        #endregion

        #region Float, FloatArray
        /// <summary>
        /// Gets the wrapped data as a 32-bit floating point number.
        /// </summary>
        /// <returns></returns>
        public float AsFloat()
        {
            return (float)Data;
        }

        /// <summary>
        /// Gets the wrapped data as an array of 32-bit floating point numbers.
        /// </summary>
        /// <returns></returns>
        public float[] AsFloatArray()
        {
            return (float[])Data;
        }
        #endregion

        #region Double, DoubleArray
        /// <summary>
        /// Gets the wrapped data as a 64-bit floating point number.
        /// </summary>
        /// <returns></returns>
        public double AsDouble()
        {
            return (double)Data;
        }

        /// <summary>
        /// Gets the wrapped data as an array of 64-bit floating point numbers.
        /// </summary>
        /// <returns></returns>
        public double[] AsDoubleArray()
        {
            return (double[])Data;
        }
        #endregion

        #region String, StringArray
        /// <summary>
        /// Gets the wrapped data as a string.
        /// </summary>
        /// <returns></returns>
        public string AsString()
        {
            return (string)Data;
        }

        /// <summary>
        /// Gets the wrapped data as an array of strings.
        /// </summary>
        /// <returns></returns>
        public string[] AsStringArray()
        {
            return (string[])Data;
        }
        #endregion

        #region GSArray, GSObject
        /// <summary>
        /// Gets the wrapped data as a GSArray.
        /// </summary>
        /// <returns></returns>
        public IGSArray AsGSArray()
        {
            return (GSArray)Data;
        }

        /// <summary>
        /// Gets the wrapped data as an array of GSObject.
        /// </summary>
        /// <returns></returns>
        public IGSObject AsGSObject()
        {
            return (GSObject)Data;
        }
        #endregion
    }