NewtonSoft在runTime添加JSONIGNORE

Question

我希望使用NewtonSoft JSON序列化列表,我需要在序列化时忽略其中一个属性,我得到以下代码

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

但我在我的应用程序中的许多地方使用此特定类汽车,我想只在一个地方排除选项.

我可以在我需要的特定位置动态添加[JsonIgnore]吗？我怎么做 ？

Answer 1

不需要做其他答案中解释的复杂的东西.

NewtonSoft JSON具有内置功能:

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

它被称为"条件属性序列化",文档可以在这里找到.

警告:首先,摆脱[JsonIgnore]你的{get;set;}财产是很重要的.否则它将覆盖该ShouldSerializeXYZ行为.

Answer 2

我认为最好使用自定义IContractResolver来实现这一目标:

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

LINQ可能不正确,我没有机会测试这个.然后您可以按如下方式使用它:

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

有关更多信息,请参阅文档.

Answer 3

根据上面的@Underscore帖子,我创建了一个要在序列化时排除的属性列表.

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

使用:

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

Answer 4

通过引用动态重命名或忽略属性而不更改序列化类，我们可以在运行时实现 JsonIgnore。这是一个可行的解决方案。

以 Person 类为例：

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

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

第 1 步：创建类“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;
}
}

第 2 步：在您的方法中添加 Jsonignore 想要应用的代码

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