这里是我对如何实现所需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();
}
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();
}
}
AutoMapper
将领域对象映射到所需的类中?它的语法非常接近您要寻找的内容。 - code4life... new { Identifier = x.Id, ...}
- Ian Mercer