예제 #1
0
        T DeserializeWithLengthPrefixExt2 <T>(Stream stream, IFormatterResolver resolver)
        {
            const int ExtTypeCode = 111; // sample ext code

            var header = MessagePackBinary.ReadExtensionFormat(stream);

            if (header.TypeCode == ExtTypeCode)
            {
                return(serializer.Deserialize <T>(header.Data, resolver));
            }
            else
            {
                throw new Exception();
            }
        }
예제 #2
0
        static int ToJsonCore(byte[] bytes, int offset, StringBuilder builder)
        {
            var readSize = 0;
            var type     = MessagePackBinary.GetMessagePackType(bytes, offset);

            switch (type)
            {
            case MessagePackType.Integer:
                var code = bytes[offset];
                if (MessagePackCode.MinNegativeFixInt <= code && code <= MessagePackCode.MaxNegativeFixInt)
                {
                    builder.Append(MessagePackBinary.ReadSByte(bytes, offset, out readSize));
                }
                else if (MessagePackCode.MinFixInt <= code && code <= MessagePackCode.MaxFixInt)
                {
                    builder.Append(MessagePackBinary.ReadByte(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.Int8)
                {
                    builder.Append(MessagePackBinary.ReadSByte(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.Int16)
                {
                    builder.Append(MessagePackBinary.ReadInt16(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.Int32)
                {
                    builder.Append(MessagePackBinary.ReadInt32(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.Int64)
                {
                    builder.Append(MessagePackBinary.ReadInt64(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.UInt8)
                {
                    builder.Append(MessagePackBinary.ReadByte(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.UInt16)
                {
                    builder.Append(MessagePackBinary.ReadUInt16(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.UInt32)
                {
                    builder.Append(MessagePackBinary.ReadUInt32(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.UInt64)
                {
                    builder.Append(MessagePackBinary.ReadUInt64(bytes, offset, out readSize));
                }
                break;

            case MessagePackType.Boolean:
                builder.Append(MessagePackBinary.ReadBoolean(bytes, offset, out readSize) ? "true" : "false");
                break;

            case MessagePackType.Float:
                var floatCode = bytes[offset];
                if (floatCode == MessagePackCode.Float32)
                {
                    builder.Append(MessagePackBinary.ReadSingle(bytes, offset, out readSize).ToString(System.Globalization.CultureInfo.InvariantCulture));
                }
                else
                {
                    builder.Append(MessagePackBinary.ReadDouble(bytes, offset, out readSize).ToString(System.Globalization.CultureInfo.InvariantCulture));
                }
                break;

            case MessagePackType.String:
                WriteJsonString(MessagePackBinary.ReadString(bytes, offset, out readSize), builder);
                break;

            case MessagePackType.Binary:
                builder.Append("\"" + Convert.ToBase64String(MessagePackBinary.ReadBytes(bytes, offset, out readSize)) + "\"");
                break;

            case MessagePackType.Array:
            {
                var length        = MessagePackBinary.ReadArrayHeaderRaw(bytes, offset, out readSize);
                var totalReadSize = readSize;
                offset += readSize;
                builder.Append("[");
                for (int i = 0; i < length; i++)
                {
                    readSize       = ToJsonCore(bytes, offset, builder);
                    offset        += readSize;
                    totalReadSize += readSize;

                    if (i != length - 1)
                    {
                        builder.Append(",");
                    }
                }
                builder.Append("]");

                return(totalReadSize);
            }

            case MessagePackType.Map:
            {
                var length        = MessagePackBinary.ReadMapHeaderRaw(bytes, offset, out readSize);
                var totalReadSize = readSize;
                offset += readSize;
                builder.Append("{");
                for (int i = 0; i < length; i++)
                {
                    // write key
                    {
                        var keyType = MessagePackBinary.GetMessagePackType(bytes, offset);
                        if (keyType == MessagePackType.String || keyType == MessagePackType.Binary)
                        {
                            readSize = ToJsonCore(bytes, offset, builder);
                        }
                        else
                        {
                            builder.Append("\"");
                            readSize = ToJsonCore(bytes, offset, builder);
                            builder.Append("\"");
                        }
                        offset        += readSize;
                        totalReadSize += readSize;
                    }

                    builder.Append(":");

                    // write body
                    {
                        readSize       = ToJsonCore(bytes, offset, builder);
                        offset        += readSize;
                        totalReadSize += readSize;
                    }

                    if (i != length - 1)
                    {
                        builder.Append(",");
                    }
                }
                builder.Append("}");

                return(totalReadSize);
            }

            case MessagePackType.Extension:
                var extHeader = MessagePackBinary.ReadExtensionFormatHeader(bytes, offset, out readSize);
                if (extHeader.TypeCode == ReservedMessagePackExtensionTypeCode.DateTime)
                {
                    var dt = MessagePackBinary.ReadDateTime(bytes, offset, out readSize);
                    builder.Append("\"");
                    builder.Append(dt.ToString("o", CultureInfo.InvariantCulture));
                    builder.Append("\"");
                }
                else
                {
                    var ext = MessagePackBinary.ReadExtensionFormat(bytes, offset, out readSize);
                    builder.Append("[");
                    builder.Append(ext.TypeCode);
                    builder.Append(",");
                    builder.Append("\"");
                    builder.Append(Convert.ToBase64String(ext.Data));
                    builder.Append("\"");
                    builder.Append("]");
                }
                break;

            case MessagePackType.Unknown:
            case MessagePackType.Nil:
            default:
                readSize = 1;
                builder.Append("null");
                break;
            }

            return(readSize);
        }
        static int ToJsonCore(byte[] bytes, int offset, StringBuilder builder)
        {
            var readSize = 0;
            var type     = MessagePackBinary.GetMessagePackType(bytes, offset);

            switch (type)
            {
            case MessagePackType.Integer:
                var code = bytes[offset];
                if (MessagePackCode.MinNegativeFixInt <= code && code <= MessagePackCode.MaxNegativeFixInt)
                {
                    builder.Append(MessagePackBinary.ReadSByte(bytes, offset, out readSize));
                }
                else if (MessagePackCode.MinFixInt <= code && code <= MessagePackCode.MaxFixInt)
                {
                    builder.Append(MessagePackBinary.ReadByte(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.Int8)
                {
                    builder.Append(MessagePackBinary.ReadSByte(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.Int16)
                {
                    builder.Append(MessagePackBinary.ReadInt16(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.Int32)
                {
                    builder.Append(MessagePackBinary.ReadInt32(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.Int64)
                {
                    builder.Append(MessagePackBinary.ReadInt64(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.UInt8)
                {
                    builder.Append(MessagePackBinary.ReadByte(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.UInt16)
                {
                    builder.Append(MessagePackBinary.ReadUInt16(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.UInt32)
                {
                    builder.Append(MessagePackBinary.ReadUInt32(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.UInt64)
                {
                    builder.Append(MessagePackBinary.ReadUInt64(bytes, offset, out readSize));
                }
                break;

            case MessagePackType.Boolean:
                builder.Append(MessagePackBinary.ReadBoolean(bytes, offset, out readSize) ? "true" : "false");
                break;

            case MessagePackType.Float:
                var floatCode = bytes[offset];
                if (floatCode == MessagePackCode.Float32)
                {
                    builder.Append(MessagePackBinary.ReadSingle(bytes, offset, out readSize).ToString(System.Globalization.CultureInfo.InvariantCulture));
                }
                else
                {
                    builder.Append(MessagePackBinary.ReadDouble(bytes, offset, out readSize).ToString(System.Globalization.CultureInfo.InvariantCulture));
                }
                break;

            case MessagePackType.String:
                WriteJsonString(MessagePackBinary.ReadString(bytes, offset, out readSize), builder);
                break;

            case MessagePackType.Binary:
                builder.Append("\"" + Convert.ToBase64String(MessagePackBinary.ReadBytes(bytes, offset, out readSize)) + "\"");
                break;

            case MessagePackType.Array:
            {
                var length        = MessagePackBinary.ReadArrayHeaderRaw(bytes, offset, out readSize);
                var totalReadSize = readSize;
                offset += readSize;
                builder.Append("[");
                for (int i = 0; i < length; i++)
                {
                    readSize       = ToJsonCore(bytes, offset, builder);
                    offset        += readSize;
                    totalReadSize += readSize;

                    if (i != length - 1)
                    {
                        builder.Append(",");
                    }
                }
                builder.Append("]");

                return(totalReadSize);
            }

            case MessagePackType.Map:
            {
                var length        = MessagePackBinary.ReadMapHeaderRaw(bytes, offset, out readSize);
                var totalReadSize = readSize;
                offset += readSize;
                builder.Append("{");
                for (int i = 0; i < length; i++)
                {
                    // write key
                    {
                        var keyType = MessagePackBinary.GetMessagePackType(bytes, offset);
                        if (keyType == MessagePackType.String || keyType == MessagePackType.Binary)
                        {
                            readSize = ToJsonCore(bytes, offset, builder);
                        }
                        else
                        {
                            builder.Append("\"");
                            readSize = ToJsonCore(bytes, offset, builder);
                            builder.Append("\"");
                        }
                        offset        += readSize;
                        totalReadSize += readSize;
                    }

                    builder.Append(":");

                    // write body
                    {
                        readSize       = ToJsonCore(bytes, offset, builder);
                        offset        += readSize;
                        totalReadSize += readSize;
                    }

                    if (i != length - 1)
                    {
                        builder.Append(",");
                    }
                }
                builder.Append("}");

                return(totalReadSize);
            }

            case MessagePackType.Extension:
                var extHeader = MessagePackBinary.ReadExtensionFormatHeader(bytes, offset, out readSize);
                if (extHeader.TypeCode == ReservedMessagePackExtensionTypeCode.DateTime)
                {
                    var dt = MessagePackBinary.ReadDateTime(bytes, offset, out readSize);
                    builder.Append("\"");
                    builder.Append(dt.ToString("o", CultureInfo.InvariantCulture));
                    builder.Append("\"");
                }
#if NETSTANDARD || NETFRAMEWORK
                else if (extHeader.TypeCode == TypelessFormatter.ExtensionTypeCode)
                {
                    int startOffset = offset;
                    // prepare type name token
                    offset += 6;
                    var typeNameToken    = new StringBuilder();
                    var typeNameReadSize = ToJsonCore(bytes, offset, typeNameToken);
                    offset += typeNameReadSize;
                    int startBuilderLength = builder.Length;
                    if (extHeader.Length > typeNameReadSize)
                    {
                        // object map or array
                        var typeInside = MessagePackBinary.GetMessagePackType(bytes, offset);
                        if (typeInside != MessagePackType.Array && typeInside != MessagePackType.Map)
                        {
                            builder.Append("{");
                        }
                        offset += ToJsonCore(bytes, offset, builder);
                        // insert type name token to start of object map or array
                        if (typeInside != MessagePackType.Array)
                        {
                            typeNameToken.Insert(0, "\"$type\":");
                        }
                        if (typeInside != MessagePackType.Array && typeInside != MessagePackType.Map)
                        {
                            builder.Append("}");
                        }
                        if (builder.Length - startBuilderLength > 2)
                        {
                            typeNameToken.Append(",");
                        }
                        builder.Insert(startBuilderLength + 1, typeNameToken.ToString());
                    }
                    else
                    {
                        builder.Append("{\"$type\":\"" + typeNameToken.ToString() + "}");
                    }
                    readSize = offset - startOffset;
                }
#endif
                else
                {
                    var ext = MessagePackBinary.ReadExtensionFormat(bytes, offset, out readSize);
                    builder.Append("[");
                    builder.Append(ext.TypeCode);
                    builder.Append(",");
                    builder.Append("\"");
                    builder.Append(Convert.ToBase64String(ext.Data));
                    builder.Append("\"");
                    builder.Append("]");
                }
                break;

            case MessagePackType.Unknown:
            case MessagePackType.Nil:
            default:
                readSize = 1;
                builder.Append("null");
                break;
            }

            return(readSize);
        }
예제 #4
0
        public object Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
        {
            var type = MessagePackBinary.GetMessagePackType(bytes, offset);

            switch (type)
            {
            case MessagePackType.Integer:
                var code = bytes[offset];
                if (MessagePackCode.MinNegativeFixInt <= code && code <= MessagePackCode.MaxNegativeFixInt)
                {
                    return(MessagePackBinary.ReadSByte(bytes, offset, out readSize));
                }
                else if (MessagePackCode.MinFixInt <= code && code <= MessagePackCode.MaxFixInt)
                {
                    return(MessagePackBinary.ReadByte(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.Int8)
                {
                    return(MessagePackBinary.ReadSByte(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.Int16)
                {
                    return(MessagePackBinary.ReadInt16(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.Int32)
                {
                    return(MessagePackBinary.ReadInt32(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.Int64)
                {
                    return(MessagePackBinary.ReadInt64(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.UInt8)
                {
                    return(MessagePackBinary.ReadByte(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.UInt16)
                {
                    return(MessagePackBinary.ReadUInt16(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.UInt32)
                {
                    return(MessagePackBinary.ReadUInt32(bytes, offset, out readSize));
                }
                else if (code == MessagePackCode.UInt64)
                {
                    return(MessagePackBinary.ReadUInt64(bytes, offset, out readSize));
                }
                throw new InvalidOperationException("Invalid primitive bytes.");

            case MessagePackType.Boolean:
                return(MessagePackBinary.ReadBoolean(bytes, offset, out readSize));

            case MessagePackType.Float:
                if (MessagePackCode.Float32 == bytes[offset])
                {
                    return(MessagePackBinary.ReadSingle(bytes, offset, out readSize));
                }
                else
                {
                    return(MessagePackBinary.ReadDouble(bytes, offset, out readSize));
                }

            case MessagePackType.String:
                return(MessagePackBinary.ReadString(bytes, offset, out readSize));

            case MessagePackType.Binary:
                return(MessagePackBinary.ReadBytes(bytes, offset, out readSize));

            case MessagePackType.Extension:
                var ext = MessagePackBinary.ReadExtensionFormat(bytes, offset, out readSize);
                if (ext.TypeCode == ReservedMessagePackExtensionTypeCode.DateTime)
                {
                    return(MessagePackBinary.ReadDateTime(bytes, offset, out readSize));
                }
                throw new InvalidOperationException("Invalid primitive bytes.");

            case MessagePackType.Array:
            {
                var length      = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
                var startOffset = offset;
                offset += readSize;

                var array = new object[length];
                for (int i = 0; i < length; i++)
                {
                    array[i] = Deserialize(bytes, offset, formatterResolver, out readSize);
                    offset  += readSize;
                }

                readSize = offset - startOffset;
                return(array);
            }

            case MessagePackType.Map:
            {
                var length      = MessagePackBinary.ReadMapHeader(bytes, offset, out readSize);
                var startOffset = offset;
                offset += readSize;

                var hash = new Dictionary <object, object>(length);
                for (int i = 0; i < length; i++)
                {
                    var key = Deserialize(bytes, offset, formatterResolver, out readSize);
                    offset += readSize;

                    var value = Deserialize(bytes, offset, formatterResolver, out readSize);
                    offset += readSize;

                    hash.Add(key, value);
                }

                readSize = offset - startOffset;
                return(hash);
            }

            case MessagePackType.Nil:
                readSize = 1;
                return(null);

            default:
                throw new InvalidOperationException("Invalid primitive bytes.");
            }
        }
        public static string ReadComment(byte[] bytes, int offset, out int readSize)
        {
            var result = MessagePackBinary.ReadExtensionFormat(bytes, offset, out readSize);

            return(Encoding.ASCII.GetString(result.Data));
        }