Json.net lent de sérialisation et de désérialisation

J'ai un problème - Json.Net la sérialisation de mes objets vraiment lent. J'ai une certaine catégorie de base:

public class authenticationRequest
{
    public string userid;
    public string tid;
    public string token;
    public string platform;
    public string version;
}

Et je suis sérialisation avec

string jsonDataToSend = JsonConvert.SerializeObject(dataToSend);

Cette opération prend environ 1900 mme. À comparer à des informations à partir de Json.net CodePlex page:

Json.net lent de sérialisation et de désérialisation

Il prend beaucoup de temps. À des fins de test, j'ai troqué ma classe pour une simple chaîne de caractères:

string jsonDataToSend = JsonConvert.SerializeObject("fsdfsdfsdfs");

Et encore, il faut ~900 ms convertir. Quelle est la raison? Ce que je peux faire pour sérialiser des données plus rapide?

avez-vous un débogueur? est systématiquement qui se passe?
avez-vous exécuter plusieurs itérations?
En plus de @DanielA.Le blanc de ses préoccupations, comment le ~900ms comparer à DataContractJsonSerializer et JavaScriptSerializer (par exemple, avez-vous recréé l'ensemble de l'indice de référence, ou tout simplement Json.NET)?
Si vous exécutez la sérialisation deux fois, le second prend autant de temps?
Essayer de l'exécuter deux fois de suite, et de voir ce que le temps est pour le deuxième. Il peut être quelque chose dans le constructeur ou le chargement de la bibliothèque qui prend le plus de temps. (jamais d'avis sur le constructeur. J'ai juste regardé la source, et il n'y en a pas).

OriginalL'auteur Thaven | 2012-04-10

.net c#json.net windows-phone-7.1

6

Je crois que ce qui se passe ici est que vous avez un retard lors de la Json.Net la bibliothèque est en cours de chargement. Vous devriez essayer de compiler en mode Release, pour voir si les choses s'accélèrent considérablement, ce qui devrait éviter des symboles de chargement (ce qui peut ajouter à la bibliothèque de temps de chargement).

Si c'est toujours un problème, trouver un bon temps dans votre application que vous pouvez faire un mannequin de sérialisation (peut-être même sur un thread d'arrière-plan) à la force de la bibliothèque à charger. Qui a un peu de code-odeur à elle, cependant, il peut donc y avoir une meilleure façon de forcer la charge, mais c'est une force brute qui doit travailler tout le temps.

OriginalL'auteur Robaticus

J'ai eu le même problème avec un projet que je suis en train de travailler sur et je l'ai résolu en suivant les conseils sur cette page:
http://www.newtonsoft.com/json/help/html/Performance.htm

Plus précisément, ils recommandent manuellement la sérialisation de vos objets quand la performance est essentielle:

public static string ToJson(this Person p)
{
    StringWriter sw = new StringWriter();
    JsonTextWriter writer = new JsonTextWriter(sw);

    //{
    writer.WriteStartObject();

    //"name" : "Jerry"
    writer.WritePropertyName("name");
    writer.WriteValue(p.Name);

    //"likes": ["Comedy", "Superman"]
    writer.WritePropertyName("likes");
    writer.WriteStartArray();
    foreach (string like in p.Likes)
    {
        writer.WriteValue(like);
    }
    writer.WriteEndArray();

    //}
    writer.WriteEndObject();

    return sw.ToString();
}

Mon exemple en VB ressemble à ceci:

    Public Function SerializeWords(ByRef oWords As List(Of Word))
        Dim sb As New StringBuilder
        Dim sw As New IO.StringWriter(sb)
        Using oWriter As Newtonsoft.Json.JsonWriter = New Newtonsoft.Json.JsonTextWriter(sw)
            With oWriter
                .WriteStartArray()
                For Each oWord As Word In oWords
                    .WriteStartObject()

                    .WritePropertyName("ID")
                    .WriteValue(oWord.ID)

                    .WritePropertyName("Phonics")
                    .WriteValue(oWord.Phonics)

                    .WritePropertyName("Word_")
                    .WriteValue(oWord.Word_)

                    .WritePropertyName("WordLength")
                    .WriteValue(oWord.WordLength)

                    .WriteEndObject()
                Next
                .WriteEndArray()

            End With
        End Using
        Return sb.ToString

    End Function

Remarquez comment il est fortement typé. Je crois que lorsque vous utilisez
Newtonsoft.Json.JsonConvert.SerializeObject()
c'est à l'aide de la réflexion pour faire le travail (qui peut vraiment ajouter jusqu'à quand vous avez beaucoup d'objets avec de nombreuses propriétés).

De toute façon... une fois que j'ai écrit mes propres sérialiseur, mon temps sérialisation d'une liste de 250 mots est passé de 28 secondes à l'aide d'JsonConvert.SerializeObject() la méthode de 31 millisecondes à l'aide de mon propre fonction.

OriginalL'auteur Frog Pr1nce

1

Chaîne JSON désérialisation à l'aide de la "Newtonsoft.Json" bibliothèque des œuvres beaucoup plus rapide pour moi sur les BRAS lors de la désérialisation de l' dynamic type de données au lieu d'un programme personnalisé.
```
var receivedObject = JsonConvert.DeserializeObject<dynamic>(content);
```
mais c'est encore plus rapide:
```
dynamic receivedObject = JObject.Parse(content);
```
OriginalL'auteur JedatKinports

Vous devez vous connecter pour publier un commentaire.