Usar JSON.NET para generar el esquema JSON con atributos adicionales

Question

Estoy usando JSON.NET para generar el esquema JSON desde la clase de objeto C#. Pero no pude agregar ningún otro atributo de esquema json, p. maxLength, patrón (regex para validar el correo electrónico), etc.

A continuación se muestra mi código de trabajo, solo puedo generar el esquema json con el atributo requerido. Sería genial si alguien puede publicar un ejemplo de código sobre cómo agregar esos atributos adicionales para el esquema json.

Gracias,

mi código de ejemplo

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

Se podría utilizar el 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); 
     } 
    } 
} 

utilizar de esta manera:

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

Lea también este artículo:

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

También puede intentar ServiceStack JsonSerializer

Un ejemplo de uso:

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

Answer 2

Se pueden crear a medida JsonConverter algo como esto. Usé la reflexión para completar las propiedades.

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

• primer convertido usted en archivo JSON a XML
• añadir ahora nodo XML que desea agregar y convertir XML a JSON.

Esta conversión se puede realizar fácilmente por la clase 'newtonsoft.json.jsonconvert'. Para los usos de esta clase solo importa newtonsoft.json dll en tu proyecto.

Answer 4

Json.NET Schema ahora tiene soporte de generación de esquemas muy mejorado.

Puede anotar propiedades con los atributos de anotación de datos de .NET para especificar información como mínimo, máximo, minLength, maxLength y más en un esquema.

También hay JSchemaGenerationProvider que le permite tener un control total al generar un esquema para un tipo.

Más detalles aquí: http://www.newtonsoft.com/jsonschema/help/html/GeneratingSchemas.htm

Answer 5

James Newton-King es justo en his answer, sólo voy a expandirlo con un ejemplo de código para que la gente tropiezo en esta página no tienen que estudiar todo el documentation.

Así que usted puede utilizar los atributos proporcionados con .NET para especificar las opciones addidional, como la longitud máxima de la cadena o el patrón de expresión permitida. He aquí algunos ejemplos:

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

Las anotaciones anteriormente provienen de System.ComponentModel.DataAnnotations espacio de nombres.

para hacer esos atributos adicionales afectan resultante esquema JSON, es necesario utilizar JSchemaGenerator clase distribuido con Json.NET esquema paquete. Si usa más viejo JsonSchemaGenerator, entonces se necesita un poco de actualización, ya que es obsoleto y no contiene nuevas funciones como la mencionada.

Aquí es una función de ejemplo que genera JSON Esquema para la clase anterior:

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

y se puede usar como este:

string schema = GenerateSchemaForClass(typeof(MyDataModel));