Kann Json.NET in einen Stream serialisieren / deserialisieren?

Ich habe gehört, dass Json.NET schneller als DataContractJsonSerializer ist, und wollte es versuchen ...

Aber ich konnte auf JsonConvert keine Methoden finden, die einen Stream anstelle eines Strings verwenden.

Zum Deserialisieren einer Datei, die JSON auf WinPhone enthält, verwende ich beispielsweise den folgenden Code, um den Dateiinhalt in eine Zeichenfolge zu lesen und dann in JSON zu deserialisieren. In meinen (sehr ad-hoc) Tests scheint es ungefähr viermal langsamer zu sein als mit DataContractJsonSerializer, um direkt aus dem Stream zu deserialisieren ...

// 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);

Mache ich es falsch

UPDATE: Dies funktioniert in der aktuellen Version nicht mehr. Die richtige Antwort finden Sie weiter unten (Sie müssen nicht abstimmen, dies ist bei älteren Versionen korrekt ).

Verwenden Sie die JsonTextReaderKlasse mit a StreamReaderoder verwenden Sie die JsonSerializerÜberladung, die a StreamReaderdirekt benötigt:

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

In der aktuellen Version von Json.net können Sie den akzeptierten Antwortcode nicht verwenden. Eine aktuelle Alternative ist:

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);
    }
}

Dokumentation: Deserialisieren Sie JSON aus einem Dateistream

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);
    }
}

Ich habe eine Erweiterungsklasse geschrieben, die mir beim Deserialisieren aus JSON-Quellen (Zeichenfolge, Stream, Datei) hilft.

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;
    }
}

Deserialisieren ist jetzt so einfach wie Schreiben:

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

Hoffe, es wird jemand anderem helfen.

Ich kam zu dieser Frage und suchte nach einer Möglichkeit, eine offene Liste von Objekten auf eine zu streamen System.IO.Streamund sie am anderen Ende abzulesen, ohne die gesamte Liste vor dem Senden zu puffern. (Insbesondere streame ich persistierte Objekte von MongoDB über die Web-API.)

@Paul Tyng und @Rivers haben die ursprüngliche Frage hervorragend beantwortet, und ich habe ihre Antworten verwendet, um einen Proof of Concept für mein Problem zu erstellen. Ich habe beschlossen, meine Testkonsolen-App hier zu veröffentlichen, falls jemand anderes mit dem gleichen Problem konfrontiert ist.

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);
            }
        }
    }
}

Beachten Sie, dass Sie möglicherweise eine Ausnahme erhalten, wenn das AnonymousPipeServerStreamentsorgt wird. Ich habe dies ignoriert, da es für das vorliegende Problem nicht relevant ist.