Esempio n. 1
0
 public void Serialize(ref JsonWriter ptr, TargetClassContractless targetClassContractless, IJsonFormatterResolver jsonFormatterResolver)
 {
     if (targetClassContractless == null)
     {
         ptr.WriteNull();
         return;
     }
     UnsafeMemory64.WriteRaw11(ref ptr, this.stringByteKeys[0]);
     ptr.WriteSByte(targetClassContractless.Number1);
     UnsafeMemory64.WriteRaw11(ref ptr, this.stringByteKeys[1]);
     ptr.WriteInt16(targetClassContractless.Number2);
     UnsafeMemory64.WriteRaw11(ref ptr, this.stringByteKeys[2]);
     ptr.WriteInt32(targetClassContractless.Number3);
     UnsafeMemory64.WriteRaw11(ref ptr, this.stringByteKeys[3]);
     ptr.WriteInt64(targetClassContractless.Number4);
     UnsafeMemory64.WriteRaw11(ref ptr, this.stringByteKeys[4]);
     ptr.WriteByte(targetClassContractless.Number5);
     UnsafeMemory64.WriteRaw11(ref ptr, this.stringByteKeys[5]);
     ptr.WriteUInt16(targetClassContractless.Number6);
     UnsafeMemory64.WriteRaw11(ref ptr, this.stringByteKeys[6]);
     ptr.WriteUInt32(targetClassContractless.Number7);
     UnsafeMemory64.WriteRaw11(ref ptr, this.stringByteKeys[7]);
     ptr.WriteUInt64(targetClassContractless.Number8);
     UnsafeMemory64.WriteRaw7(ref ptr, this.stringByteKeys[8]);
     ptr.WriteString(targetClassContractless.Str);
     UnsafeMemory64.WriteRaw9(ref ptr, this.stringByteKeys[9]);
     JsonFormatterResolverExtensions.GetFormatterWithVerify <int[]>(jsonFormatterResolver).Serialize(ref ptr, targetClassContractless.Array, jsonFormatterResolver);
     ptr.WriteEndObject();
 }
        public void Serialize(ref JsonWriter writer, TrackAlbumAssociation trackAlbumAssociation, IJsonFormatterResolver formatterResolver)
        {
            if (trackAlbumAssociation == null)
            {
                writer.WriteNull();
                return;
            }

            UnsafeMemory64.WriteRaw9(ref writer, this.stringByteKeys[0]);
            formatterResolver.GetFormatter <Album>().Serialize(ref writer, trackAlbumAssociation.Album, formatterResolver);

            UnsafeMemory64.WriteRaw14(ref writer, this.stringByteKeys[1]);
            if (trackAlbumAssociation.DiscNumber.HasValue)
            {
                writer.WriteUInt32(trackAlbumAssociation.DiscNumber.Value);
            }
            else
            {
                writer.WriteNull();
            }

            UnsafeMemory64.WriteRaw15(ref writer, this.stringByteKeys[2]);
            if (trackAlbumAssociation.TrackNumber.HasValue)
            {
                writer.WriteUInt32(trackAlbumAssociation.TrackNumber.Value);
            }
            else
            {
                writer.WriteNull();
            }

            writer.WriteEndObject();
        }
Esempio n. 3
0
        public void Serialize(ref JsonWriter writer, Artist artist, IJsonFormatterResolver formatterResolver)
        {
            if (artist == null)
            {
                writer.WriteNull();
                return;
            }

            UnsafeMemory64.WriteRaw8(ref writer, this.artistNameBytes);
            writer.WriteString(artist.Name);

            writer.WriteEndObject();
        }
Esempio n. 4
0
    public void Serialize(ref JsonWriter writer, SimplePerson value, IJsonFormatterResolver formatterResolver)
    {
        if (value == null)
        {
            writer.WriteNull(); return;
        }

        UnsafeMemory64.WriteRaw7(ref writer, nameCaches[0]); // optimize byte->byte copy we know src size.
        writer.WriteInt32(value.Age);
        UnsafeMemory64.WriteRaw13(ref writer, nameCaches[1]);
        writer.WriteString(value.FirstName);
        UnsafeMemory64.WriteRaw12(ref writer, nameCaches[2]);
        writer.WriteString(value.LastName);

        writer.WriteEndObject();
    }
Esempio n. 5
0
    public void _SerializePattern2Test(ref JsonWriter writer, SimplePerson value, IJsonFormatterResolver formatterResolver)
    {
        if (value == null)
        {
            writer.WriteNull(); return;
        }

        bool wrote = false;

        writer.WriteBeginObject();
        // if(value.Age != nul)
        {
            if (wrote == false)
            {
                wrote = true;
                writer.WriteValueSeparator();
            }

            UnsafeMemory64.WriteRaw7(ref writer, nameCaches2[0]);
            writer.WriteInt32(value.Age);
        }
        if (value.FirstName != null)
        {
            if (wrote == false)
            {
                wrote = true;
                writer.WriteValueSeparator();
            }

            UnsafeMemory64.WriteRaw13(ref writer, nameCaches2[1]);
            writer.WriteString(value.FirstName);
        }
        if (value.LastName != null)
        {
            if (wrote == false)
            {
                wrote = true;
                writer.WriteValueSeparator();
            }

            UnsafeMemory64.WriteRaw12(ref writer, nameCaches2[2]);
            writer.WriteString(value.LastName);
        }

        writer.WriteEndObject();
    }
Esempio n. 6
0
        public void Serialize(ref JsonWriter writer, Track track, IJsonFormatterResolver formatterResolver)
        {
            if (track == null)
            {
                writer.WriteNull();
                return;
            }

            var dateTimeFormatter = formatterResolver.GetFormatter <DateTime>();

            UnsafeMemory64.WriteRaw26(ref writer, this.stringByteKeys[0]);
            dateTimeFormatter.Serialize(ref writer, track.AddedToLibraryDateTime, formatterResolver);

            UnsafeMemory64.WriteRaw20(ref writer, this.stringByteKeys[1]);
            formatterResolver.GetFormatter <TrackAlbumAssociation>().Serialize(ref writer, track.AlbumAssociation, formatterResolver);

            UnsafeMemory64.WriteRaw9(ref writer, this.stringByteKeys[2]);
            IJsonFormatterHelper.SerializeList(ref writer, track.Composers, formatterResolver);

            UnsafeMemory64.WriteRaw12(ref writer, this.stringByteKeys[3]);
            formatterResolver.GetFormatter <TimeSpan?>().Serialize(ref writer, track.Duration, formatterResolver);

            UnsafeMemory64.WriteRaw17(ref writer, this.stringByteKeys[4]);
            formatterResolver.GetFormatter <ulong?>().Serialize(ref writer, track.FileSizeBytes, formatterResolver);

            UnsafeMemory64.WriteRaw11(ref writer, this.stringByteKeys[5]);
            writer.WriteBoolean(track.IsLoved);

            UnsafeMemory64.WriteRaw24(ref writer, this.stringByteKeys[6]);
            formatterResolver.GetFormatter <DateTime?>().Serialize(ref writer, track.LastModifiedDateTime, formatterResolver);

            UnsafeMemory64.WriteRaw12(ref writer, this.stringByteKeys[8]);
            formatterResolver.GetFormatter <Uri>().Serialize(ref writer, track.Location, formatterResolver);

            UnsafeMemory64.WriteRaw14(ref writer, this.stringByteKeys[9]);
            IJsonFormatterHelper.SerializeList(ref writer, track.Performers, formatterResolver);

            UnsafeMemory64.WriteRaw9(ref writer, this.stringByteKeys[10]);
            writer.WriteString(track.Title);

            UnsafeMemory64.WriteRaw8(ref writer, this.stringByteKeys[11]);
            formatterResolver.GetFormatter <uint?>().Serialize(ref writer, track.Year, formatterResolver);

            writer.WriteEndObject();
        }
        public void Serialize(ref JsonWriter writer, Album album, IJsonFormatterResolver formatterResolver)
        {
            if (album == null)
            {
                writer.WriteNull();
                return;
            }

            UnsafeMemory64.WriteRaw11(ref writer, this.stringByteKeys[0]);
            IJsonFormatterHelper.SerializeList(ref writer, album.Authors, formatterResolver);

            UnsafeMemory64.WriteRaw14(ref writer, this.stringByteKeys[1]);
            if (album.DiscsCount.HasValue)
            {
                writer.WriteUInt32(album.DiscsCount.Value);
            }
            else
            {
                writer.WriteNull();
            }

            UnsafeMemory64.WriteRaw9(ref writer, this.stringByteKeys[2]);
            writer.WriteString(album.Title);

            // TODO: try use get serialize <uint?>
            UnsafeMemory64.WriteRaw15(ref writer, this.stringByteKeys[3]);
            if (album.TracksCount.HasValue)
            {
                writer.WriteUInt32(album.TracksCount.Value);
            }
            else
            {
                writer.WriteNull();
            }

            writer.WriteEndObject();
        }