Json.NET può serializzare / deserializzare su / da uno stream?

Ho sentito che Json.NET è più veloce di DataContractJsonSerializer e ho voluto provare ...

Ma non sono riuscito a trovare alcun metodo su JsonConvert che utilizzi un flusso anziché una stringa.

Per deserializzare un file contenente JSON su WinPhone, ad esempio, utilizzo il codice seguente per leggere il contenuto del file in una stringa, quindi deserializzare in JSON. Sembra essere circa 4 volte più lento nei miei test (molto ad hoc) rispetto all'utilizzo di DataContractJsonSerializer per deserializzare direttamente dallo stream ...

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

Sto sbagliando?

AGGIORNAMENTO: non funziona più nella versione corrente, vedi sotto per la risposta corretta ( non è necessario votare in basso, questo è corretto nelle versioni precedenti ).

Utilizzare la JsonTextReaderclasse con a StreamReadero utilizzare il JsonSerializersovraccarico che accetta StreamReaderdirettamente un :

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

La versione corrente di Json.net non consente di utilizzare il codice di risposta accettato. Un'alternativa attuale è:

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

Documentazione: deserializzare JSON da un flusso di file

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

Ho scritto una classe di estensione per aiutarmi a deserializzare dalle fonti JSON (stringa, flusso, file).

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

Deserializzare ora è facile come scrivere:

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

Spero che possa aiutare qualcun altro.

Sono arrivato a questa domanda alla ricerca di un modo per trasmettere in streaming un elenco di oggetti senza fine su un System.IO.Streame leggerli dall'altra parte, senza bufferizzare l'intero elenco prima di inviarlo. (In particolare sto trasmettendo oggetti persistenti da MongoDB su API Web.)

@Paul Tyng e @Rivers hanno fatto un ottimo lavoro rispondendo alla domanda originale, e ho usato le loro risposte per costruire una prova di concetto per il mio problema. Ho deciso di pubblicare qui la mia app della console di test nel caso in cui altri si trovino ad affrontare lo stesso problema.

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

Nota che potresti ricevere un'eccezione quando AnonymousPipeServerStreamviene eliminata, l'ho ignorata poiché non è rilevante per il problema in questione.