Json.NET bir akışa / akıştan serileştirebilir / seriyi kaldırabilir mi?

Json.NET'in DataContractJsonSerializer'dan daha hızlı olduğunu duydum ve denemek istedim ...

Ancak JsonConvert üzerinde dizeden ziyade akış alan herhangi bir yöntem bulamadım.

Örneğin, WinPhone'da JSON içeren bir dosyanın serisini kaldırmak için, aşağıdaki kodu kullanarak dosya içeriğini bir dizeye okudum ve ardından JSON olarak seriyi kaldırıyorum. (Çok geçici) testimde, DataContractJsonSerializer'ı doğrudan akıştan seri durumdan çıkarmak için kullanmaktan yaklaşık 4 kat daha yavaş görünüyor ...

// DCJS
DataContractJsonSerializer dc = new DataContractJsonSerializer(typeof(Constants));
Constants constants = (Constants)dc.ReadObject(stream);

// JSON.NET
string json = new StreamReader(stream).ReadToEnd();
Constants constants = JsonConvert.DeserializeObject<Constants>(json);

Yanlış mı yapıyorum?

GÜNCELLEME: Bu artık mevcut sürümde çalışmamaktadır, doğru yanıt için aşağıya bakın ( geri oylamaya gerek yoktur, bu eski sürümlerde doğrudur ).

Kullan JsonTextReaderbir ile sınıf StreamReaderveya kullanmak JsonSerializerbir sürer aşırı StreamReaderdoğrudan:

var serializer = new JsonSerializer();
serializer.Deserialize(streamReader);

Json.net'in mevcut sürümü, kabul edilen cevap kodunu kullanmanıza izin vermiyor. Mevcut bir alternatif:

public static object DeserializeFromStream(Stream stream)
{
    var serializer = new JsonSerializer();

    using (var sr = new StreamReader(stream))
    using (var jsonTextReader = new JsonTextReader(sr))
    {
        return serializer.Deserialize(jsonTextReader);
    }
}

Dokümantasyon: Bir dosya akışından JSON serisini kaldır

public static void Serialize(object value, Stream s)
{
    using (StreamWriter writer = new StreamWriter(s))
    using (JsonTextWriter jsonWriter = new JsonTextWriter(writer))
    {
        JsonSerializer ser = new JsonSerializer();
        ser.Serialize(jsonWriter, value);
        jsonWriter.Flush();
    }
}

public static T Deserialize<T>(Stream s)
{
    using (StreamReader reader = new StreamReader(s))
    using (JsonTextReader jsonReader = new JsonTextReader(reader))
    {
        JsonSerializer ser = new JsonSerializer();
        return ser.Deserialize<T>(jsonReader);
    }
}

JSON kaynaklarından (dizge, akış, dosya) seriyi kaldırmama yardımcı olacak bir uzantı sınıfı yazdım.

public static class JsonHelpers
{
    public static T CreateFromJsonStream<T>(this Stream stream)
    {
        JsonSerializer serializer = new JsonSerializer();
        T data;
        using (StreamReader streamReader = new StreamReader(stream))
        {
            data = (T)serializer.Deserialize(streamReader, typeof(T));
        }
        return data;
    }

    public static T CreateFromJsonString<T>(this String json)
    {
        T data;
        using (MemoryStream stream = new MemoryStream(System.Text.Encoding.Default.GetBytes(json)))
        {
            data = CreateFromJsonStream<T>(stream);
        }
        return data;
    }

    public static T CreateFromJsonFile<T>(this String fileName)
    {
        T data;
        using (FileStream fileStream = new FileStream(fileName, FileMode.Open))
        {
            data = CreateFromJsonStream<T>(fileStream);
        }
        return data;
    }
}

Seriyi kaldırmak artık yazmak kadar kolay:

MyType obj1 = aStream.CreateFromJsonStream<MyType>();
MyType obj2 = "{\"key\":\"value\"}".CreateFromJsonString<MyType>();
MyType obj3 = "data.json".CreateFromJsonFile<MyType>();

Umarım başkasına yardımcı olur.

Bu soruya, açık uçlu bir nesne System.IO.Streamlistesini göndermeden önce tüm listeyi ara belleğe almadan, bir nesneye akıtmanın ve diğer uçtan okumanın bir yolunu ararken ulaştım. (Özellikle Web API üzerinden MongoDB'den kalıcı nesnelerin akışını yapıyorum.)

@Paul Tyng ve @Rivers orijinal soruyu yanıtlarken mükemmel bir iş çıkardılar ve ben de onların yanıtlarını sorunum için bir kavram kanıtı oluşturmak için kullandım. Başka birinin aynı sorunla karşılaşması durumunda test konsolu uygulamamı burada yayınlamaya karar verdim.

using System;
using System.Diagnostics;
using System.IO;
using System.IO.Pipes;
using System.Threading;
using System.Threading.Tasks;
using Newtonsoft.Json;

namespace TestJsonStream {
    class Program {
        static void Main(string[] args) {
            using(var writeStream = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.None)) {
                string pipeHandle = writeStream.GetClientHandleAsString();
                var writeTask = Task.Run(() => {
                    using(var sw = new StreamWriter(writeStream))
                    using(var writer = new JsonTextWriter(sw)) {
                        var ser = new JsonSerializer();
                        writer.WriteStartArray();
                        for(int i = 0; i < 25; i++) {
                            ser.Serialize(writer, new DataItem { Item = i });
                            writer.Flush();
                            Thread.Sleep(500);
                        }
                        writer.WriteEnd();
                        writer.Flush();
                    }
                });
                var readTask = Task.Run(() => {
                    var sw = new Stopwatch();
                    sw.Start();
                    using(var readStream = new AnonymousPipeClientStream(pipeHandle))
                    using(var sr = new StreamReader(readStream))
                    using(var reader = new JsonTextReader(sr)) {
                        var ser = new JsonSerializer();
                        if(!reader.Read() || reader.TokenType != JsonToken.StartArray) {
                            throw new Exception("Expected start of array");
                        }
                        while(reader.Read()) {
                            if(reader.TokenType == JsonToken.EndArray) break;
                            var item = ser.Deserialize<DataItem>(reader);
                            Console.WriteLine("[{0}] Received item: {1}", sw.Elapsed, item);
                        }
                    }
                });
                Task.WaitAll(writeTask, readTask);
                writeStream.DisposeLocalCopyOfClientHandle();
            }
        }

        class DataItem {
            public int Item { get; set; }
            public override string ToString() {
                return string.Format("{{ Item = {0} }}", Item);
            }
        }
    }
}

İmha edildiğinde bir istisna alabileceğinizi unutmayın, AnonymousPipeServerStreammevcut sorunla ilgili olmadığı için bunu görmezden geldim.