Beispiel #1
0
        public T Deserialize <T>([NotNull] Stream stream)
        {
            DeserializerSession session = GetDeserializerSession();
            var s = GetDeserializerByManifest(stream, session);

            return((T)s.ReadValue(stream, session));
        }
Beispiel #2
0
        public object Deserialize([NotNull] Stream stream)
        {
            var session = new DeserializerSession(this);
            var s       = GetDeserializerByManifest(stream, session);

            return(s.ReadValue(stream, session));
        }
Beispiel #3
0
        public ValueSerializer GetDeserializerByManifest([NotNull] Stream stream, [NotNull] DeserializerSession session)
        {
            var first = stream.ReadByte();

            if (first <= 250)
            {
                return(_deserializerLookup[first]);
            }
            switch (first)
            {
            case ConsistentArraySerializer.Manifest:
                return(ConsistentArraySerializer.Instance);

            case ObjectReferenceSerializer.Manifest:
                return(ObjectReferenceSerializer.Instance);

            case ObjectSerializer.ManifestFull:
            {
                var type = TypeEx.GetTypeFromManifestFull(stream, session);
                return(GetCustomDeserializer(type));
            }

            case ObjectSerializer.ManifestVersion:
            {
                var type = TypeEx.GetTypeFromManifestVersion(stream, session);
                return(GetCustomDeserializer(type));
            }

            case ObjectSerializer.ManifestIndex:
            {
                var typeId = (int)stream.ReadUInt16(session);
                if (typeId < _knownValueSerializers.Length)
                {
                    return(_knownValueSerializers[typeId]);
                }
                var type = TypeEx.GetTypeFromManifestIndex(typeId, session);
                return(GetCustomDeserializer(type));
            }

            default:
                throw new NotSupportedException("Unknown manifest value");
            }
        }
        static StructDeserializeBenchmark()
        {
            ProtoInput = new MemoryStream();
            ProtoBuf.Serializer.Serialize(ProtoInput, IntStruct.Create());

            HyperionInput = new MemoryStream();
            HyperionSerializer.Serialize(IntStruct.Create(), HyperionInput);

            // Hagar
            var services = new ServiceCollection()
                           .AddHagar(hagar => hagar.AddAssembly(typeof(Program).Assembly))
                           .BuildServiceProvider();

            HagarSerializer = services.GetRequiredService <ValueSerializer <IntStruct> >();
            Session         = services.GetRequiredService <SerializerSessionPool>().GetSession();
            var       bytes     = new byte[1000];
            var       writer    = new SingleSegmentBuffer(bytes).CreateWriter(Session);
            IntStruct intStruct = IntStruct.Create();

            HagarSerializer.Serialize(ref intStruct, ref writer);
            HagarHandCraftedSerializer = new HagarGen_Serializer_IntStruct_1843466();
            HagarInput = bytes;

            HyperionSession = HyperionSerializer.GetDeserializerSession();

            Utf8JsonInput = Utf8JsonNS.JsonSerializer.Serialize(IntStruct.Create(), Utf8JsonResolver);

            var stream = new MemoryStream();

            using (var jsonWriter = new System.Text.Json.Utf8JsonWriter(stream))
            {
                System.Text.Json.JsonSerializer.Serialize <IntStruct>(jsonWriter, IntStruct.Create());
            }

            SystemTextJsonInput = stream.ToArray();
        }