La fusion de deux objets, lors de la sérialisation à l'aide json.net?

J'ai rencontré une situation comme ci-dessous quelqu'un pourrait-il m'aider à atteindre comme ci-dessous?

Par Exemple, si j'ai la classe:-

public class Sample
{
    public String name {get;set;}
    public MyClass myclass {get;set;}
}

Mon Myclass sera comme suit:

public class MyClass
{
    public String p1 {get;set;}
    public String p2 {get;set;}
}

Quand je suis en utilisant Json.net de Sérialiser l'objet de la classe de l'Échantillon,j'ai eu comme ci-dessous et il fonctionne bien.

{
 "name":"...",
 "myclass":
          {
            "p1":"...",
            "p2":"..."
           }
 }

Son correct, mais je me demande est-il possible d'obtenir la chaîne json comme ci-dessous?

{
 "name":"...",
 "p1":"...",
 "p2":"..."
}

OriginalL'auteur Madhu | 2013-11-06

  1. 21

    Vous pouvez créer des objet anonyme et sérialiser:

    var sample = new Sample { 
    name = "Bob", 
    myclass = new MyClass { 
                p1 = "x", 
                p2 = "y" 
              }};

string json = JsonConvert.SerializeObject(new { 
                 sample.name, 
                 sample.myclass.p1, 
                 sample.myclass.p2 
              });

    Résultat

    {"name":"Bob","p1":"x","p2":"y"}

    Mais je vous suggère d'utiliser sérialisation par défaut de votre Sample de classe, ou de créer une classe qui va être sérialisé dans votre format (c'est à dire déplacer MyClass propriétés dans Sample).

    Mise à JOUR: Vous pouvez utiliser convertisseur personnalisé, qui s'aplatit objet et sérialise tous les objets internes de propriétés de haut niveau des propriétés de l'objet:

    public class FlattenJsonConverter : JsonConverter
{
    public override void WriteJson(JsonWriter writer, object value, 
        JsonSerializer serializer)
    {
        JToken t = JToken.FromObject(value);
        if (t.Type != JTokenType.Object)
        {
            t.WriteTo(writer);
            return;
        }

        JObject o = (JObject)t;
        writer.WriteStartObject();
        WriteJson(writer, o);
        writer.WriteEndObject();
    }

    private void WriteJson(JsonWriter writer, JObject value)
    {
        foreach (var p in value.Properties())
        {
            if (p.Value is JObject)
                WriteJson(writer, (JObject)p.Value);
            else
                p.WriteTo(writer);
        }
    }

    public override object ReadJson(JsonReader reader, Type objectType, 
       object existingValue, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override bool CanConvert(Type objectType)
    {
        return true; //works for any type
    }
}

    Utilisation:

    string json = JsonConvert.SerializeObject(sample, new FlattenJsonConverter());

    Ou vous pouvez tout simplement cacher anonyme de type création en convertisseur personnalisé, si vous avez besoin de ce comportement pour un type seulement:

    public class SampleJsonConverter : JsonConverter
{
    public override void WriteJson(JsonWriter writer, 
        object value, JsonSerializer serializer)
    {
        Sample sample = (Sample)value;
        JToken t = JToken.FromObject(new { 
                      sample.name, 
                      sample.myclass.p1, 
                      sample.myclass.p2 
                   });

        t.WriteTo(writer);
    }

    public override object ReadJson(JsonReader reader, Type objectType,
        object existingValue, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(Sample);
    }
}
    Merci pour votre aide copain. Est-il possible de faire cela en utilisant CustomConverters?
    Je pense que Le code ci-dessus ne sera pas commode lorsque la propriété de la classe a de plus un certain nombre de propriétés.
    Merci copain je vais vous laisser savoir après je vérifie.

    OriginalL'auteur Sergey Berezovskiy