JSON.net Serialize Object met root-naam

In mijn web-app gebruik ik newtonsoft.json en ik heb het volgende object

[Newtonsoft.Json.JsonObject(Title = "MyCar")]
public class Car
{
    [Newtonsoft.Json.JsonProperty(PropertyName = "name")]
    public string Name{get;set;}
    [Newtonsoft.Json.JsonProperty(PropertyName = "owner")]
    public string Owner{get;set;}
}

en ik wil ze serialiseren met rootnaam (klasnaam). Dit is het gewenste formaat met

{'MyCar':
 {
   'name': 'Ford',
   'owner': 'John Smith'
 }
}

Ik weet dat ik dat kan doen met anoniem object, maar is een eigendom of een andere manier in Newtonoft.json Library?

Antwoord 1, Autoriteit 100%

Anonieme klasse

Vorm uw model zoals u anonieme klassen wilt gebruiken:

var root = new 
{ 
    car = new 
    { 
        name = "Ford", 
        owner = "Henry"
    }
};
string json = JsonConvert.SerializeObject(root);

Antwoord 2, Autoriteit 93%

Ik vond een gemakkelijke manier om dit uit te geven … Verklaar gewoon een dynamisch object en wijs het eerste item in het dynamische object toe om uw verzamelklasse te zijn … dit voorbeeld gaat ervan uit dat u newtonsoft.json

private class YourModelClass
{
    public string firstName { get; set; }
    public string lastName { get; set; }
}
var collection = new List<YourModelClass>();
var collectionWrapper = new {
    myRoot = collection
};
var output = JsonConvert.SerializeObject(collectionWrapper);

Waar je mee moet eindigen is zoiets:

{"myRoot":[{"firstName":"John", "lastName": "Citizen"}, {...}]}

Antwoord 3, Autoriteit 32%

U kunt eenvoudig uw eigen serializer maken

var car = new Car() { Name = "Ford", Owner = "John Smith" };
string json = Serialize(car);

string Serialize<T>(T o)
{
    var attr = o.GetType().GetCustomAttribute(typeof(JsonObjectAttribute)) as JsonObjectAttribute;
    var jv = JValue.FromObject(o);
    return new JObject(new JProperty(attr.Title, jv)).ToString();
}

Antwoord 4, Autoriteit 17%

Sorry, mijn Engels is niet zo goed. Maar ik hou van de up-vermelde antwoorden verbeteren.
Ik denk dat het gebruik van woordenboek eenvoudiger en schoon is.

class Program
    {
        static void Main(string[] args)
        {
            agencia ag1 = new agencia()
            {
                name = "Iquique",
                data = new object[] { new object[] {"Lucas", 20 }, new object[] {"Fernando", 15 } }
            };
            agencia ag2 = new agencia()
            {
                name = "Valparaiso",
                data = new object[] { new object[] { "Rems", 20 }, new object[] { "Perex", 15 } }
            };
            agencia agn = new agencia()
            {
                name = "Santiago",
                data = new object[] { new object[] { "Jhon", 20 }, new object[] { "Karma", 15 } }
            };
            Dictionary<string, agencia> dic = new Dictionary<string, agencia>
            {
                { "Iquique", ag1 },
                { "Valparaiso", ag2 },
                { "Santiago", agn }
            };
            string da = Newtonsoft.Json.JsonConvert.SerializeObject(dic);
            Console.WriteLine(da);
            Console.ReadLine();
        }
    }
    public class agencia
    {
        public string name { get; set; }
        public object[] data { get; set; }
    }

Deze code genereert de volgende JSON (dit is gewenst formaat)

{  
   "Iquique":{  
      "name":"Iquique",
      "data":[  
         [  
            "Lucas",
            20
         ],
         [  
            "Fernando",
            15
         ]
      ]
   },
   "Valparaiso":{  
      "name":"Valparaiso",
      "data":[  
         [  
            "Rems",
            20
         ],
         [  
            "Perex",
            15
         ]
      ]
   },
   "Santiago":{  
      "name":"Santiago",
      "data":[  
         [  
            "Jhon",
            20
         ],
         [  
            "Karma",
            15
         ]
      ]
   }
}

Antwoord 5, autoriteit 10%

string Json = JsonConvert.SerializeObject(new Car { Name = "Ford", Owner = "John Smith" }, Formatting.None);

gebruik voor het root-element GlobalConfiguration.

Antwoord 6, autoriteit 10%

Een heel eenvoudige benadering voor mij is om gewoon 2 klassen te maken.

public class ClassB
{
    public string id{ get; set; }
    public string name{ get; set; }
    public int status { get; set; }
    public DateTime? updated_at { get; set; }
}
public class ClassAList
{
    public IList<ClassB> root_name{ get; set; } 
}

En wanneer je serialisatie gaat doen:

var classAList = new ClassAList();
//...
//assign some value
//...
var jsonString = JsonConvert.SerializeObject(classAList)

Ten slotte ziet u het gewenste resultaat als volgt:

{
  "root_name": [
    {
      "id": "1001",
      "name": "1000001",
      "status": 1010,
      "updated_at": "2016-09-28 16:10:48"
    },
    {
      "id": "1002",
      "name": "1000002",
      "status": 1050,
      "updated_at": "2016-09-28 16:55:55"
    }
  ]
}

Hopelijk helpt dit!

Antwoord 7, autoriteit 7%

Nou, je kunt Json.NET op zijn minst vertellen om de typenaam op te nemen: http://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_TypeNameHandling.htm. Newtonsoft.Json.JsonSerializer jser = new Newtonsoft.Json.JsonSerializer();
jser.TypeNameHandling = TypeNameHandling.Objects;

Het type wordt aan het begin opgenomen in de eigenschap “$type” van het object.

Dit is niet precies wat u zoekt, maar het was goed genoeg voor mij toen ik met een soortgelijk probleem werd geconfronteerd.

Antwoord 8, autoriteit 5%

Het schrijven van een aangepaste JsonConverteris een andere benadering die in soortgelijke vragen wordt genoemd . Vanwege de aard van hoe JsonConverteris ontworpen, is het echter lastig om die benadering voor deze vraag te gebruiken, omdat u voorzichtig moet zijn met de implementatie van WriteJsonom te voorkomen dat u in oneindige recursie terechtkomt : JSON.Net genereert StackOverflowException bij gebruik van [JsonConvert()].

Eén mogelijke implementatie:

public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
    //JToken t = JToken.FromObject(value); // do not use this! leads to stack overflow
    JsonObjectContract contract = (JsonObjectContract)serializer.ContractResolver.ResolveContract(value.GetType());
    writer.WriteStartObject();
    writer.WritePropertyName(value.GetType().Name);
    writer.WriteStartObject();
    foreach (var property in contract.Properties)
    {
        // this removes any property with null value
        var propertyValue = property.ValueProvider.GetValue(value);
        if (propertyValue == null) continue;
        writer.WritePropertyName(property.PropertyName);
        serializer.Serialize(writer, propertyValue);
        //writer.WriteValue(JsonConvert.SerializeObject(property.ValueProvider.GetValue(value))); // this adds escaped quotes
    }
    writer.WriteEndObject();
    writer.WriteEndObject();
}

Antwoord 9, Autoriteit 2%

Ik hoop dat deze hulp is.

//Sample of Data Contract:
[DataContract(Name="customer")]
internal class Customer {
  [DataMember(Name="email")] internal string Email { get; set; }
  [DataMember(Name="name")] internal string Name { get; set; }
}
//This is an extension method useful for your case:
public static string JsonSerialize<T>(this T o)
{
  MemoryStream jsonStream = new MemoryStream();
  var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(T));
  serializer.WriteObject(jsonStream, o);
  var jsonString = System.Text.Encoding.ASCII.GetString(jsonStream.ToArray());
  var props = o.GetType().GetCustomAttributes(false);
  var rootName = string.Empty;
  foreach (var prop in props)
  {
    if (!(prop is DataContractAttribute)) continue;
    rootName = ((DataContractAttribute)prop).Name;
    break;
  }
  jsonStream.Close();
  jsonStream.Dispose();
  if (!string.IsNullOrEmpty(rootName)) jsonString = string.Format("{{ \"{0}\": {1} }}", rootName, jsonString);
  return jsonString;
}
//Sample of usage
var customer = new customer { 
Name="John",
Email="[email protected]"
};
var serializedObject = customer.JsonSerialize();

Antwoord 10

[Newtonsoft.Json.JsonObject(Title = "root")]
public class TestMain

Dit is de enige attrib die u moet toevoegen om uw code te krijgen.