所以，我得到了一堆我需要序列化/反序列化的类，它们也 碰巧是域对象(至少是其中的一些)，因此我希望它们 是否有任何属性取决于特定的框架。

我查看了 Json.NET 中的自定义转换器，但它们对我来说看起来非常“古老” 在使用和其他方面，因为我们现在有泛型，但它不是 很难实现流畅的界面。所以在我走上弱类型等道路之前..

...我在找什么(伪):

public class MyModel {
    public int Id { get; set; }
    public string Name { get; set; }
    public SomeObj SomeObj { get; set; }
}

public class MyModelConverter : JsonConverter<MyModel> {

    public JsonConverter() {
        RuleFor(x => x.Id).Name("Identifier");
        RuleFor(x => x.SomeObj).Name("Data")
            .WithConverter(new SomeObjConverter());
        RuleFor(x => x.Name).Ignore();
    }

}

Json.NET 中有类似的东西吗？我只是错过了什么吗？ (顺便说一句，我不能为我的属性等使用不同的名称，因为这些模型基于第 3 方规范)。

最佳答案

以下是我对实现所需 API 的看法:

根据评论编辑

public abstract class Rule
{
    private Dictionary<string, object> rule { get; } = new Dictionary<string, object>();

    protected void AddRule(string key, object value)
    {
        if (rule.ContainsKey(key))
        {
            rule.Add(key, value);
        }
        else
        {
            rule[key] = value;
        }
    }

    protected IEnumerable<KeyValuePair<string, object>> RegisteredRules
    {
        get
        {
            return rule.AsEnumerable();
        }
    }
}

public abstract class PropertyRule : Rule
{
    public MemberInfo PropertyInfo { get; protected set; }

    public void Update(JsonProperty contract)
    {
        var props = typeof(JsonProperty).GetProperties();
        foreach (var rule in RegisteredRules)
        {
            var property = props.Where(x => x.Name == rule.Key).FirstOrDefault();
            if (property != null)
            {
                var value = rule.Value;
                if (property.PropertyType == value.GetType())
                {
                    property.SetValue(contract, value);
                }
            }
        }
    }
}

public class PropertyRule<TClass, TProp> : PropertyRule
{
    public const string CONVERTER_KEY = "Converter";
    public const string PROPERTY_NAME_KEY = "PropertyName";
    public const string IGNORED_KEY = "Ignored";

    public PropertyRule(Expression<Func<TClass, TProp>> prop)
    {
        PropertyInfo = (prop.Body as System.Linq.Expressions.MemberExpression).Member;
    }

    public PropertyRule<TClass, TProp> Converter(JsonConverter converter)
    {
        AddRule(CONVERTER_KEY, converter);
        return this;
    }

    public PropertyRule<TClass, TProp> Name(string propertyName)
    {
        AddRule(PROPERTY_NAME_KEY, propertyName);
        return this;
    }

    public PropertyRule<TClass, TProp> Ignore()
    {
        AddRule(IGNORED_KEY, true);
        return this;
    }
}

public interface SerializationSettings
{
    IEnumerable<Rule> Rules { get; }
}

public class SerializationSettings<T> : SerializationSettings
{
    private List<Rule> rules { get; } = new List<Rule>();

    public IEnumerable<Rule> Rules { get; private set; }

    public SerializationSettings()
    {
        Rules = rules.AsEnumerable();
    }

    public PropertyRule<T, TProp> RuleFor<TProp>(Expression<Func<T, TProp>> prop)
    {
        var rule = new PropertyRule<T, TProp>(prop);
        rules.Add(rule);
        return rule;
    }
}

public class FluentContractResolver : DefaultContractResolver
{
    static List<SerializationSettings> settings;

    public static void SearchAssemblies(params Assembly[] assemblies)
    {
        SearchAssemblies((IEnumerable<Assembly>)assemblies);
    }

    public static void SearchAssemblies(IEnumerable<Assembly> assemblies)
    {
        settings = assemblies.SelectMany(x => x.GetTypes()).Where(t => IsSubclassOfRawGeneric(t, typeof(SerializationSettings<>))).Select(t => (SerializationSettings)Activator.CreateInstance(t)).ToList();
    }

    //http://stackoverflow.com/questions/457676/check-if-a-class-is-derived-from-a-generic-class
    static bool IsSubclassOfRawGeneric(System.Type toCheck, System.Type generic)
    {
        if (toCheck != generic)
        {
            while (toCheck != null && toCheck != typeof(object))
            {
                var cur = toCheck.GetTypeInfo().IsGenericType ? toCheck.GetGenericTypeDefinition() : toCheck;
                if (generic == cur)
                {
                    return true;
                }
                toCheck = toCheck.GetTypeInfo().BaseType;
            }
        }
        return false;
    }

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

        var rule = settings.Where(x => x.GetType().GetTypeInfo().BaseType.GenericTypeArguments[0] == member.DeclaringType).SelectMany(x => x.Rules.Select(r => r as PropertyRule).Where(r => r != null && r.PropertyInfo.Name == member.Name)).FirstOrDefault();
        if (rule != null)
        {
            rule.Update(contract);
        }
        return contract;
    }
}

现在在程序启动的某个地方:

FluentContractResolver.SearchAssemblies(typeof(MyModel).GetTypeInfo().Assembly);

Newtonsoft.Json.JsonConvert.DefaultSettings = () => 
{
    return new Newtonsoft.Json.JsonSerializerSettings
    {
        Formatting = Newtonsoft.Json.Formatting.Indented,
        ContractResolver = new FluentContractResolver()
    };
};

有了这个，你现在只需要添加具有流畅设置的类:

public class MyModelSettings : SerializationSettings<MyModel> 
{

    public MyModelSettings() 
    {
        RuleFor(x => x.Id).Name("Identifier");
        RuleFor(x => x.SomeObj).Name("Data").Converter(new SomeObjConverter());
        RuleFor(x => x.Name).Ignore();
    }

}

关于c# - 使用 Json.NET 的流利转换器/映射器？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/26801453/