Json.NET peut-il sérialiser / désérialiser vers / depuis un flux?

J'ai entendu dire que Json.NET est plus rapide que DataContractJsonSerializer, et je voulais l'essayer ...

Mais je n'ai pas trouvé de méthodes sur JsonConvert qui prennent un flux plutôt qu'une chaîne.

Pour désérialiser un fichier contenant JSON sur WinPhone, par exemple, j'utilise le code suivant pour lire le contenu du fichier dans une chaîne, puis désérialiser en JSON. Il semble être environ 4 fois plus lent dans mes tests (très ad hoc) que d'utiliser DataContractJsonSerializer pour désérialiser directement à partir du flux ...

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

Est-ce que je fais mal?

MISE À JOUR: Cela ne fonctionne plus dans la version actuelle, voir ci - dessous pour la bonne réponse ( pas besoin de voter contre, c'est correct sur les anciennes versions ).

Utilisez la JsonTextReaderclasse avec a StreamReaderou utilisez la JsonSerializersurcharge qui prend StreamReaderdirectement un :

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

La version actuelle de Json.net ne vous permet pas d'utiliser le code de réponse accepté. Une alternative actuelle est:

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

Documentation: désérialiser JSON à partir d'un flux de fichiers

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

J'ai écrit une classe d'extension pour m'aider à désérialiser des sources JSON (chaîne, flux, fichier).

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

Désérialiser est désormais aussi simple que d'écrire:

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

J'espère que cela aidera quelqu'un d'autre.

Je suis arrivé à cette question à la recherche d'un moyen de diffuser une liste d'objets ouverte sur un System.IO.Streamet de les lire à l'autre extrémité, sans mettre en mémoire tampon la liste entière avant l'envoi. (Plus précisément, je diffuse des objets persistants de MongoDB sur l'API Web.)

@Paul Tyng et @Rivers ont fait un excellent travail en répondant à la question initiale, et j'ai utilisé leurs réponses pour construire une preuve de concept pour mon problème. J'ai décidé de publier mon application de console de test ici au cas où quelqu'un d'autre serait confronté au même problème.

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

Notez que vous pouvez recevoir une exception lorsque le AnonymousPipeServerStreamest supprimé, j'ai ignoré cela car cela n'est pas pertinent pour le problème en question.