web-dev-qa-db-fra.com

NewtonSoft ajoute JSONIGNORE au runTime

Je cherche à sérialiser une liste à l’aide de NewtonSoft JSON et j’ai besoin d’ignorer l’une des propriétés en cours de sérialisation et j’ai obtenu le code ci-dessous.

public class Car
{
  // included in JSON
  public string Model { get; set; }
  // ignored
  [JsonIgnore]
  public DateTime LastModified { get; set; }
}

Mais j'utilise cette voiture de classe spécifique à plusieurs endroits dans mon application et je veux exclure l'option uniquement à un endroit.

Puis-je ajouter dynamiquement [JsonIgnore] au lieu spécifique où j'ai besoin? Comment je fais ça ?

c#attributesjson.net
23
Peru

Pas besoin de faire les choses compliquées expliquées dans l'autre réponse.

NewtonSoft JSON a une fonctionnalité intégrée pour cela:

public bool ShouldSerializeINSERT_YOUR_PROPERTY_NAME_HERE()
{
    if(someCondition){
        return true;
    }else{
        return false;
    }
}

C'est ce qu'on appelle "la sérialisation conditionnelle des propriétés" et la documentation peut être trouvée ici .

Attention: tout d'abord, il est important de se débarrasser de [JsonIgnore] au-dessus de votre propriété {get;set;}. Sinon, le comportement ShouldSerializeXYZ sera écrasé.

47
Xavier Peña

Je pense qu'il serait préférable d'utiliser un IContractResolver personnalisé pour atteindre cet objectif:

public class DynamicContractResolver : DefaultContractResolver
{
    private readonly string _propertyNameToExclude;

    public DynamicContractResolver(string propertyNameToExclude)
    {
        _propertyNameToExclude = propertyNameToExclude;
    }

    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        IList<JsonProperty> properties = base.CreateProperties(type, memberSerialization);

        // only serializer properties that are not named after the specified property.
        properties =
            properties.Where(p => string.Compare(p.PropertyName, _propertyNameToExclude, true) != 0).ToList();

        return properties;
    }
}

Le LINQ n'est peut-être pas correct, je n'ai pas eu l'occasion de le tester. Vous pouvez ensuite l'utiliser comme suit:

string json = JsonConvert.SerializeObject(car, Formatting.Indented,
   new JsonSerializerSettings { ContractResolver = new DynamicContractResolver("LastModified") });

Reportez-vous à la documentation pour plus d'informations.

18
Underscore

Sur la base de l'article @Underscore ci-dessus, j'ai créé une liste de propriétés à exclure lors de la sérialisation.

public class DynamicContractResolver : DefaultContractResolver {
    private readonly string[] props;

    public DynamicContractResolver(params string[] prop) {
        this.props = prop;
    }

    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization) {
        IList<JsonProperty> retval = base.CreateProperties(type, memberSerialization);

        // retorna todas as propriedades que não estão na lista para ignorar
        retval = retval.Where(p => !this.props.Contains(p.PropertyName)).ToList();

        return retval;
    }
}

Utilisation:

string json = JsonConvert.SerializeObject(car, Formatting.Indented, 
    new JsonSerializerSettings { ContractResolver = new DynamicContractResolver("ID", "CreatedAt", "LastModified") });
8
diegodsp

Essaye ça:

    public static void IgnoreProperty<T, TR>(this T parameter, Expression<Func<T, TR>> propertyLambda)
    {
        var parameterType = parameter.GetType();
        var propertyName = propertyLambda.GetReturnedPropertyName();
        if (propertyName == null)
        {
            return;
        }

        var jsonPropertyAttribute = parameterType.GetProperty(propertyName).GetCustomAttribute<JsonPropertyAttribute>();
        jsonPropertyAttribute.DefaultValueHandling = DefaultValueHandling.Ignore;
    }

    public static string GetReturnedPropertyName<T, TR>(this Expression<Func<T, TR>> propertyLambda)
    {
        var member = propertyLambda.Body as MemberExpression;
        var memberPropertyInfo = member?.Member as PropertyInfo;
        return memberPropertyInfo?.Name;
    }

Donc, vous pouvez faire ceci:

carObject.IgnoreProperty(so => so.LastModified);
0
Robert Michael Watson

Avec la référence Renommer ou ignorer dynamiquement les propriétés sans changer la classe sérialisée , nous pouvons obtenir JsonIgnore au moment de l’exécution. C'est une solution viable. 

Considérons la classe de personnes par exemple:

public class Person
{
    // ignore property
    [JsonIgnore]
    public string Title { get; set; }

// rename property
[JsonProperty("firstName")]
public string FirstName { get; set; }
}

Étape 1: Créer la classe "PropertyRenameAndIgnoreSerializerContractResolver"

public class PropertyRenameAndIgnoreSerializerContractResolver : DefaultContractResolver
{
    private readonly Dictionary<Type, HashSet<string>> _ignores;
    private readonly Dictionary<Type, Dictionary<string, string>> _renames;

public PropertyRenameAndIgnoreSerializerContractResolver()
{
    _ignores = new Dictionary<Type, HashSet<string>>();
    _renames = new Dictionary<Type, Dictionary<string, string>>();
}

public void IgnoreProperty(Type type, params string[] jsonPropertyNames)
{
    if (!_ignores.ContainsKey(type))
        _ignores[type] = new HashSet<string>();

    foreach (var prop in jsonPropertyNames)
        _ignores[type].Add(prop);
}

public void RenameProperty(Type type, string propertyName, string newJsonPropertyName)
{
    if (!_renames.ContainsKey(type))
        _renames[type] = new Dictionary<string, string>();

    _renames[type][propertyName] = newJsonPropertyName;
}

protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
{
    var property = base.CreateProperty(member, memberSerialization);

    if (IsIgnored(property.DeclaringType, property.PropertyName))
    {
        property.ShouldSerialize = i => false;
        property.Ignored = true;
    }

    if (IsRenamed(property.DeclaringType, property.PropertyName, out var newJsonPropertyName))
        property.PropertyName = newJsonPropertyName;

    return property;
}

private bool IsIgnored(Type type, string jsonPropertyName)
{
    if (!_ignores.ContainsKey(type))
        return false;

    return _ignores[type].Contains(jsonPropertyName);
}

private bool IsRenamed(Type type, string jsonPropertyName, out string newJsonPropertyName)
{
    Dictionary<string, string> renames;

    if (!_renames.TryGetValue(type, out renames) || !renames.TryGetValue(jsonPropertyName, out newJsonPropertyName))
    {
        newJsonPropertyName = null;
        return false;
    }

    return true;
}
}

Étape 2: Ajoutez du code dans votre méthode à laquelle Jsonignore souhaite appliquer

var person = new Person();
var jsonResolver = new PropertyRenameAndIgnoreSerializerContractResolver();

jsonResolver.IgnoreProperty(typeof(Person), "Title");
jsonResolver.RenameProperty(typeof(Person), "FirstName", "firstName");

var serializerSettings = new JsonSerializerSettings();
serializerSettings.ContractResolver = jsonResolver;

var json = JsonConvert.SerializeObject(person, serializerSettings);
0
Rahul Modi