Serializar objeto .Net a json, controlado mediante atributos xml

Question

Tengo un objeto .Net que he estado serializando en Xml y está decorado con atributos Xml. Ahora me gustaría serializar el mismo objeto a Json, de preferencia usando la biblioteca Newtonsoft Json.Net.

Me gustaría ir directamente desde el objeto .Net en la memoria a una cadena Json (sin serializar primero a Xml). No deseo agregar ningún atributo Json a la clase, pero en cambio me gustaría que el serializador Json use los atributos Xml existentes.

public class world{ 
    [XmlIgnore] 
    public int ignoreMe{ get; } 

    [XmlElement("foo")] 
    public int bar{ get; } 

    [XmlElement("marco")] 
    public int polo{ get; } 
} 

convierte

{ 
    "foo":0, 
    "marco":0 
} 

Answer 1

Resulta que esta no era una característica existente de la biblioteca Newtonsoft Json.Net. He escrito un parche y subido a la Json.Net issue tracker

Esto permite lo siguiente:

• XmlIgnore funciona igual que JsonIgnore.
• XmlElementAttribute.ElementName alterará el nombre de la propiedad Json.
• XmlType.AnonymousType suprimirá la impresión de objetos en Json (propiedad XmlContractResolver.SuppressAnonymousType altera este comportamiento) esto es un poco hacky, ya que he tenido que aprender las partes internas de Json.Net como he estado yendo.

Answer 2

Uso [JsonProperty(PropertyName="foo")] atributo y establezca la PropertyName.

Answer 3

La siguiente clase se puede utilizar para serializar (y deserializar) partes del árbol de objetos en XML y luego en JSON.

Uso

[JsonObject] 
public class ClassToSerializeWithJson 
{ 
    [JsonProperty] 
    public TypeThatIsJsonSerializable PropertySerializedWithJsonSerializer {get; set; } 

    [JsonProperty] 
    [JsonConverter(typeof(JsonXmlConverter<TypeThatIsXmlSerializable>))] 
    public TypeThatIsXmlSerializable PropertySerializedWithCustomSerializer {get; set; } 
} 

clase JsonXmlConverter

public class JsonXmlConverter<TType> : JsonConverter where TType : class 
{ 
    private static readonly XmlSerializer xmlSerializer = new XmlSerializer(typeof(TType)); 

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) 
    { 
     var xml = ToXml(value as TType); 
     using (var stream = new StringReader(xml)) 
     { 
      var xDoc = XDocument.Load(stream); 
      var json = JsonConvert.SerializeXNode(xDoc); 
      writer.WriteRawValue(json); 
     } 
    } 

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) 
    { 
     if (reader.TokenType == JsonToken.Null) 
     { 
      // consume the 'null' token to set the reader in the correct state 
      JToken.Load(reader); 
      return null; 
     } 
     var jObj = JObject.Load(reader); 
     var json = jObj.ToString(); 
     var xDoc = JsonConvert.DeserializeXNode(json); 
     var xml = xDoc.ToString(); 
     return FromXml(xml); 
    } 

    public override bool CanRead => true; 

    public override bool CanConvert(Type objectType) => objectType == typeof(TType); 

    private static TType FromXml(string xmlString) 
    { 
     using (StringReader reader = new StringReader(xmlString)) 
      return (TType)xmlSerializer.Deserialize(reader); 
    } 

    private static string ToXml(TType obj) 
    { 
     using (StringWriter writer = new StringWriter()) 
     using (XmlWriter xmlWriter = XmlWriter.Create(writer)) 
     { 
      XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); 
      ns.Add(String.Empty, String.Empty); 

      xmlSerializer.Serialize(xmlWriter, obj, ns); 
      return writer.ToString(); 
     } 
    } 
} 

Answer 4

Se puede crear un dispositivo de resolución de contrato de encargo que le permitirá hacer los ajustes para las propiedades y los puso a hacer caso donde un XmlIgnoreAttribute Está establecido.

public class CustomContractResolver : DefaultContractResolver 
{ 
    private readonly JsonMediaTypeFormatter formatter; 

    public CustomContractResolver(JsonMediaTypeFormatter formatter) 
    { 
     this.formatter = formatter; 
    } 

    public JsonMediaTypeFormatter Formatter 
    { 
     [DebuggerStepThrough] 
     get { return this.formatter; } 
    } 

    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization) 
    { 
     JsonProperty property = base.CreateProperty(member, memberSerialization); 
     this.ConfigureProperty(member, property); 
     return property; 
    } 

    private void ConfigureProperty(MemberInfo member, JsonProperty property) 
    { 
     if (Attribute.IsDefined(member, typeof(XmlIgnoreAttribute), true)) 
     { 
      property.Ignored = true; 
     }    
    } 
}