Usa JSON.NET per generare schema JSON con attributi aggiuntivi

Question

Sto usando JSON.NET per generare schema JSON dalla classe di oggetti C#. Ma non ero in grado di aggiungere altri attributi dello schema JSON, ad es. maxLength, pattern (regex per convalidare la posta elettronica), ecc.

Di seguito è riportato il mio codice di lavoro, posso solo generare schema json con l'attributo richiesto. Sarebbe bello se qualcuno potesse pubblicare qualche esempio di codice su come aggiungere quegli attributi extra per lo schema json.

Grazie,

codice mio esempio

public class Customer 
{ 
    [JsonProperty(Required = Required.Always)] 
    public int CustomerID { get; set; } 

    [JsonProperty(Required = Required.Always)] 
    public string FirstName { get; set; } 

    [JsonProperty(Required = Required.Always)] 
    public string LastName { get; set; } 

    [JsonProperty(Required = Required.Always)] 
    public string Email { get; set; } 

    [JsonProperty(Required = Required.AllowNull)] 
    public string Phone { get; set; } 
} 

a

{ 
    "title" : "Customer", 
    "type" : "object", 
    "properties" : { 
     "CustomerID" : { 
      "required" : true, 
      "type" : "integer" 
     }, 
     "FirstName" : { 
      "required" : true, 
      "type" : "string" 
     }, 
     "LastName" : { 
      "required" : true, 
      "type" : "string" 
     }, 
     "Email" : { 
      "required" : true, 
      "type" : "string" 
     }, 
     "Phone" : { 
      "required" : true, 
      "type" : [ 
       "string", 
       "null" 
      ] 
     } 
    } 
} 

Answer 1

È possibile utilizzare il JavaScriptSerializer class.Like:

namespace ExtensionMethods 
{ 
    public static class JSONHelper 
    { 
     public static string ToJSON(this object obj) 
     { 
      JavaScriptSerializer serializer = new JavaScriptSerializer(); 
      return serializer.Serialize(obj); 
     } 

     public static string ToJSON(this object obj, int recursionDepth) 
     { 
      JavaScriptSerializer serializer = new JavaScriptSerializer(); 
      serializer.RecursionLimit = recursionDepth; 
      return serializer.Serialize(obj); 
     } 
    } 
} 

usare in questo modo:

using ExtensionMethods; 

... 

List<Person> people = new List<Person>{ 
        new Person{ID = 1, FirstName = "Scott", LastName = "Gurthie"}, 
        new Person{ID = 2, FirstName = "Bill", LastName = "Gates"} 
        }; 


string jsonString = people.ToJSON(); 

visualizzato anche questo articolo:

1. http://msdn.microsoft.com/en-us/library/system.web.script.serialization.javascriptserializer.aspx
2. http://weblogs.asp.net/scottgu/archive/2007/10/01/tip-trick-building-a-tojson-extension-method-using-net-3-5.aspx
3. http://www.asp.net/AJAX/Documentation/Live/mref/T_System_Web_Script_Serialization_JavaScriptSerializer.aspx

si può anche provare ServiceStack JsonSerializer

Un esempio usarlo:

var customer = new Customer { Name="Joe Bloggs", Age=31 }; 
    var json = JsonSerializer.SerializeToString(customer); 
    var fromJson = JsonSerializer.DeserializeFromString<Customer>(json); 

Answer 2

È possibile creare personalizzato JsonConverter qualcosa di simile. Ho usato la riflessione per riempire le proprietà.

public class UserConverter : JsonConverter 
{ 
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) 
    { 
     var user = (User)value; 
     var result = new StringBuilder("{"); 

     result.Append("title : " + user.GetType().Name + ", "); 
     result.Append("properties : {"); 

     foreach (var prop in user.GetType().GetProperties()) 
     { 
      result.Append(prop.Name + ": {"); 
      result.Append("value : " + Convert.ToString(prop.GetValue(user, null)) + ", "); 

      var attribute = (JsonPropertyAttribute)Attribute.GetCustomAttributes(prop)[0]; 
      if (attribute.Required == Required.Always) 
       result.Append("required : true, "); 

      result.Append("type : " + prop.PropertyType.Name.ToLower()); 
      result.Append(" }"); 
     } 
     writer.WriteValue(result.ToString()); 
    } 

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) 
    { 
     var user = new User { UserName = (string)reader.Value }; 

     return user; 
    } 

    public override bool CanConvert(Type objectType) 
    { 
     return objectType == typeof(User); 
    } 

} 

---

[JsonConverter(typeof(UserConverter))] 
public class User 
{ 
    [JsonProperty(Required = Required.Always)] 
    public string UserName { get; set; } 
} 

//Run 
string json = JsonConvert.SerializeObject(manager, Formatting.Indented); 

Console.WriteLine(json); 

Answer 3

• primo convertito si file JSON per xml
• ora aggiungere nodo XML che si desidera aggiungere e convertire XML in a JSON.

Questa conversione può essere eseguita facilmente dalla classe 'newtonsoft.json.jsonconvert'. Per utilizzare questa classe è sufficiente importare newtonsoft.json dll nel progetto.

Answer 4

Json.NET Schema ora ha un supporto di generazione dello schema molto migliorato.

È possibile annotare le proprietà con gli attributi di Annotazione dati di .NET per specificare informazioni come minimo, massimo, minLength, maxLength e altro su uno schema.

C'è anche JSchemaGenerationProvider che consente di assumere il controllo completo durante la generazione di uno schema per un tipo.

Maggiori dettagli qui: http://www.newtonsoft.com/jsonschema/help/html/GeneratingSchemas.htm

Answer 5

James Newton-Re si trova proprio nel his answer, mi limiterò a espandersi con un esempio di codice così la gente inciampare su questa pagina non hanno bisogno di studiare l'intero documentation.

Quindi è possibile utilizzare gli attributi forniti con .NET per specificare queste opzioni addidional, come la lunghezza massima della stringa o espressione regolare permesso. Ecco alcuni esempi:

public class MyDataModel 
{ 
    public enum SampleEnum { EnumPosition1, EnumPosition2, EnumPosition3 } 

    [JsonProperty(Required = Required.Always)] 
    [RegularExpression(@"^[0-9]+$")] 
    public string PatternTest { get; set; } 

    [JsonProperty(Required = Required.Always)] 
    [MaxLength(3)] 
    public string MaxLength3 { get; set; } 

    [JsonProperty(Required = Required.AllowNull)] 
    [EnumDataType(typeof(SampleEnum))] 
    public string EnumProperty { get; set; } 
} 

Le annotazioni sopra provengono da System.ComponentModel.DataAnnotations namespace.

Per rendere questi attributi aggiuntivi influenti sullo schema json risultante, è necessario utilizzare la classe JSchemaGenerator distribuita con il pacchetto JSON.NET Schema. Se si utilizza lo JsonSchemaGenerator precedente, è necessario qualche aggiornamento, poiché ora è deprecato e non contiene nuove funzioni come quelle di cui sopra.

Ecco una funzione di esempio che genera JSON Schema per la classe di cui sopra:

/// <summary> 
    /// Generates JSON schema for a given C# class using Newtonsoft.Json.Schema library. 
    /// </summary> 
    /// <param name="myType">class type</param> 
    /// <returns>a string containing JSON schema for a given class type</returns> 
    internal static string GenerateSchemaForClass(Type myType) 
    { 
     JSchemaGenerator jsonSchemaGenerator = new JSchemaGenerator(); 
     JSchema schema = jsonSchemaGenerator.Generate(myType); 
     schema.Title = myType.Name; 

     return schema.ToString(); 
    } 

ed è possibile utilizzarlo proprio come questo:

string schema = GenerateSchemaForClass(typeof(MyDataModel));