仅将复杂类型字典中的某些记录序列化为 JSON

Question

I have the following contract:

class Information
{
    public string SensitiveInformation { get; set; }
    public string NotSensitiveInformation { get; set; }

    public IDictionary<string, string> PartialSensitiveInformation { get; set; }
}

My goal is to serialize the class, but I need to ommit some sensitive information. for this I've created a contract resolver:

class IgnorePropertiesContractResolver : DefaultContractResolver
{
    private readonly HashSet<string> propertyNamesToIgnore;

    public IgnorePropertiesContractResolver(HashSet<string> propertyNamesToIgnore)
    {
        this.propertyNamesToIgnore = propertyNamesToIgnore;
    }

    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        JsonProperty jsonProperty = base.CreateProperty(member, memberSerialization);
        if (this.propertyNamesToIgnore.Contains(jsonProperty.PropertyName))
        {
            jsonProperty.ShouldSerialize = x => false;
        }

        return jsonProperty;
    }
}

and running the code:

        IgnorePropertiesContractResolver resolver = new IgnorePropertiesContractResolver(new HashSet<string> {"SensitiveInformation" });

        Information info = new Information();
        info.SensitiveInformation = "sensitive data";
        info.NotSensitiveInformation = "not sensitive data";
        info.PartialSensitiveInformation = new Dictionary<string, string>();
        info.PartialSensitiveInformation["secret_data"] = "secret data";
        info.PartialSensitiveInformation["not_secret_data"] = "not secret data";

        var data = JsonConvert.SerializeObject(info, new JsonSerializerSettings { ContractResolver = resolver });

Returns this data: {"NotSensitiveInformation":"not sensitive data","PartialSensitiveInformation":{ "secret_data":"secret data" ,"not_secret_data":"not secret data"}}

Hor to change my contract resolver so I can ommit fom the serialization certain keys from the dictionary PartialSensitiveInformation ? I don't want to serialize the key "secret_data".

Please note that I have the contract in a nuget so adding attribute is not possible in this case.

I'm using .net franework 4.7.2.

Answer 1

You can implement a custom value provider (using IValueProvider ) to handle this. The value provider can take in the list of sensitive property names, and transform the dictionary to exclude the sensitive properties:

public class PartialSensitiveInformationValueProvider : IValueProvider
{
    private readonly HashSet<string> _propertyNamesToIgnore;

    public PartialSensitiveInformationValueProvider(HashSet<string> propertyNamesToIgnore)
    {
        _propertyNamesToIgnore = propertyNamesToIgnore;
    }

    public object GetValue(object target)
    {
        return ((Information)target).PartialSensitiveInformation
            .Where(x => !_propertyNamesToIgnore.Contains(x.Key))
            .ToDictionary(k => k.Key, v => v.Value);
    }

    public void SetValue(object target, object value)
    {
        throw new NotImplementedException();
    }
}

You can then use this value provider in the contract resolver:

public class IgnorePropertiesContractResolver : DefaultContractResolver
{
    private readonly HashSet<string> propertyNamesToIgnore;

    public IgnorePropertiesContractResolver(HashSet<string> propertyNamesToIgnore)
    {
        this.propertyNamesToIgnore = propertyNamesToIgnore;
    }

    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        JsonProperty jsonProperty = base.CreateProperty(member, memberSerialization);
        if (this.propertyNamesToIgnore.Contains(jsonProperty.PropertyName))
        {
            jsonProperty.ShouldSerialize = x => false;
        }

        if (jsonProperty.PropertyName == nameof(Information.PartialSensitiveInformation))
        {
            jsonProperty.ValueProvider = new PartialSensitiveInformationValueProvider(this.propertyNamesToIgnore);
        }

        return jsonProperty;
    }
}

Using the example you have (including "secret_data" in the propertyNamesToIgnore ), the results are now:

{"NotSensitiveInformation":"not sensitive data","PartialSensitiveInformation":{"not_secret_data":"not secret data"}}

Answer 2

My answer is a bit more involved than @devNull 's, the difference being it's a generic approach:

It allows you to target specific members using an expression, eg s => s.Inner.Dictionary .

Sample data:

public class MyData
{
    public Dictionary<string, string> Dictionary { get; set; } = new Dictionary<string, string>();

    public MyDataInner Inner { get; set; } = new MyDataInner();
}

public class MyDataInner
{
    public Dictionary<string, string> Dictionary { get; set; } = new Dictionary<string, string>();
}

Newtonsoft related classes, contract, converter, resolver:

public class MyJsonDictionaryContract : JsonDictionaryContract
{
    public MyJsonDictionaryContract(Type underlyingType, (string, string[])[] filters) : base(underlyingType)
    {
        Converter = new MyJsonConverter(filters);
    }
}

internal class MyJsonConverter : JsonConverter<IDictionary<string, string>>
{
    public MyJsonConverter((string, string[])[] filters)
    {
        Filters = filters;
    }

    private (string, string[])[] Filters { get; }

    public override void WriteJson(JsonWriter writer, IDictionary<string, string> value, JsonSerializer serializer)
    {
        foreach (var (k, v) in value)
        {
            var tuple = Filters.FirstOrDefault(s => s.Item1 == writer.Path);
            if (tuple != default && tuple.Item2.Contains(k))
                continue; // if Filters has path and key then NOP

            writer.WriteStartObject();
            writer.WritePropertyName(k);
            writer.WriteValue(v);
            writer.WriteEndObject();
        }
    }

    public override IDictionary<string, string> ReadJson(
        JsonReader reader,
        Type objectType,
        IDictionary<string, string> existingValue,
        bool hasExistingValue,
        JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

public class MyDataContractResolver : DefaultContractResolver
{
    public MyDataContractResolver((string, string[])[] filters)
    {
        Filters = filters;
    }

    private (string, string[])[] Filters { get; }

    protected override JsonDictionaryContract CreateDictionaryContract(Type objectType)
    {
        return new MyJsonDictionaryContract(objectType, Filters);
    }
}

The example:

internal static class Program
{
    private static void Main(string[] args)
    {
        var data = new MyData
        {
            Dictionary = new Dictionary<string, string>
            {
                {"public", "abcd"},
                {"private", "abcd"}
            },
            Inner = new MyDataInner
            {
                Dictionary = new Dictionary<string, string>
                {
                    {"public", "abcd"},
                    {"private", "abcd"}
                }
            }
        };

        var filters = new[]
        {
            (ExpressionUtils.GetPath(data, s => s.Dictionary), new[] {"private"}),
            (ExpressionUtils.GetPath(data, s => s.Inner.Dictionary), new[] {"public"})
        };

        var resolver = new MyDataContractResolver(filters);

        var settings = new JsonSerializerSettings
        {
            Formatting = Formatting.Indented,
            ContractResolver = resolver
        };

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

internal static class ExpressionUtils
{
    /// <summary>
    ///     expression 2 path, e.g. class.prop1.prop2
    /// </summary>
    public static string GetPath<TSource, TProperty>(TSource source, Expression<Func<TSource, TProperty>> property)
    {
        // https://stackoverflow.com/a/1667533/361899

        var expression = property.Body.NodeType switch
        {
            ExpressionType.Convert => (property.Body is UnaryExpression ue ? ue.Operand : null) as MemberExpression,
            ExpressionType.ConvertChecked =>
                (property.Body is UnaryExpression ue ? ue.Operand : null) as MemberExpression,
            _ => property.Body as MemberExpression
        };

        var stack = new Stack<string>();

        while (expression != null)
        {
            stack.Push(expression.Member.Name);
            expression = expression.Expression as MemberExpression;
        }

        var path = string.Join(".", stack);

        return path;
    }
}

Result without it:

{
  "Dictionary": {
    "public": "abcd",
    "private": "abcd"
  },
  "Inner": {
    "Dictionary": {
      "public": "abcd",
      "private": "abcd"
    }
  }
}

Result with it:

{
  "Dictionary": {
    "public": "abcd"
  },
  "Inner": {
    "Dictionary": {
      "private": "abcd"
    }
  }
}

So there you are, you can filter by key, but target any member whether it's nested or not.