Aggiungere un attributo personalizzato a json.net

Question

JSON.NET viene fornito con attributi di proprietà come [JsonIgnore] e [JsonProperty].

Desidero creare alcuni personalizzati che vengono eseguiti quando viene eseguita la serializzazione, ad es. [JsonIgnoreSerialize] o [JsonIgnoreDeserialize]

Come farei per estendere il framework per includere questo?

Answer 1

Poiché l'obiettivo è ignorare una proprietà sulla serializzazione ma non la deserializzazione, è possibile utilizzare uno ContractResolver.

Si noti che la seguente classe fa proprio questo, ed è basata su CamelCasePropertyNamesContractResolver, per assicurarsi che si serializzi su campi Json con casing cammello. Se non lo desideri, puoi invece ereditarlo da DefaultContractResolver.

Inoltre, l'esempio che ho avuto è basato sul nome di una stringa, ma è possibile verificare facilmente se la proprietà è decorata dal proprio attributo personalizzato anziché confrontare il nome della proprietà.

public class CamelCaseIgnoringPropertyJsonResolver<T> : CamelCasePropertyNamesContractResolver 
{   
    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization) 
    { 
     // list the properties to ignore 
     var propertiesToIgnore = type.GetProperties() 
       .Where(x => x.GetCustomAttributes().OfType<T>().Any()); 

     // Build the properties list 
     var properties = base.CreateProperties(type, memberSerialization); 

     // only serialize properties that are not ignored 
     properties = properties 
      .Where(p => propertiesToIgnore.All(info => info.Name != p.UnderlyingName)) 
      .ToList(); 

     return properties; 
    } 
} 

Quindi, è possibile utilizzarlo come segue:

static private string SerializeMyObject(object myObject) 
    { 
     var settings = new JsonSerializerSettings 
     { 
      ContractResolver = new CamelCaseIgnoringPropertyJsonResolver<JsonIgnoreSerializeAttribute>() 
     }; 

     var json = JsonConvert.SerializeObject(myObject, settings); 
     return json; 
    } 

Infine, l'attributo personalizzato può essere di qualsiasi tipo, ma per abbinare l'esempio:

internal class JsonIgnoreSerializeAttribute : Attribute 
{ 
} 

L'approccio è testato, e funziona anche con oggetti nidificati.

Answer 2

È possibile scrivere un custom contratto di resolver come questo

public class MyContractResolver<T> : Newtonsoft.Json.Serialization.DefaultContractResolver 
             where T : Attribute 
{ 
    Type _AttributeToIgnore = null; 

    public MyContractResolver() 
    { 
     _AttributeToIgnore = typeof(T); 
    } 

    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization) 
    { 
     var list = type.GetProperties() 
        .Where(x => !x.GetCustomAttributes().Any(a => a.GetType() == _AttributeToIgnore)) 
        .Select(p => new JsonProperty() 
        { 
         PropertyName = p.Name, 
         PropertyType = p.PropertyType, 
         Readable = true, 
         Writable = true, 
         ValueProvider = base.CreateMemberValueProvider(p) 
        }).ToList(); 

     return list; 
    } 
} 

Si può usare in serializzazione/deserializzazione come

var json = JsonConvert.SerializeObject(
      obj, 
      new JsonSerializerSettings() { 
       ContractResolver = new MyContractResolver<JsonIgnoreSerialize>() 
      }); 

var obj = JsonConvert.DeserializeObject<SomeType>(
      json, 
      new JsonSerializerSettings() { 
       ContractResolver = new MyContractResolver<JsonIgnoreDeserialize>() 
      });