Question

我想将一个元数据属性添加到我的json中，以便客户端可以知道哪些属性是日期。

例如，如果我有这样的对象：

{
  "notADate": "a value",
  "aDate": "2017-04-23T18:25:43.511Z",
  "anotherDate": "2017-04-23T18:25:43.511Z"
}

我想添加一个元数据属性来告诉消费者将哪些属性视为日期：

{
  "_date_properties_": ["aDate", "anotherDate"],
  "notADate": "a value",
  "aDate": "2017-04-23T18:25:43.511Z",
  "anotherDate": "2017-04-23T18:25:43.511Z"
}

任何帮助都会很棒，谢谢！

Answer 1

您可以创建一个custom ContractResolver，将合成"_date_properties_"属性插入到序列化的每个对象的合约中。

为此，第一个子类DefaultContractResolver允许在应用程序添加的事件处理程序创建合同之后对其进行流畅的自定义：

public class ConfigurableContractResolver : DefaultContractResolver
{
    readonly object contractCreatedPadlock = new object();
    event EventHandler<ContractCreatedEventArgs> contractCreated;
    int contractCount = 0;

    void OnContractCreated(JsonContract contract, Type objectType)
    {
        EventHandler<ContractCreatedEventArgs> created;
        lock (contractCreatedPadlock)
        {
            contractCount++;
            created = contractCreated;
        }
        if (created != null)
        {
            created(this, new ContractCreatedEventArgs(contract, objectType));
        }
    }

    public event EventHandler<ContractCreatedEventArgs> ContractCreated
    {
        add
        {
            lock (contractCreatedPadlock)
            {
                if (contractCount > 0)
                {
                    throw new InvalidOperationException("ContractCreated events cannot be added after the first contract is generated.");
                }
                contractCreated += value;
            }
        }
        remove
        {
            lock (contractCreatedPadlock)
            {
                if (contractCount > 0)
                {
                    throw new InvalidOperationException("ContractCreated events cannot be removed after the first contract is generated.");
                }
                contractCreated -= value;
            }
        }  
    }

    protected override JsonContract CreateContract(Type objectType)
    {
        var contract = base.CreateContract(objectType);
        OnContractCreated(contract, objectType);
        return contract;
    }
}

public class ContractCreatedEventArgs : EventArgs
{
    public JsonContract Contract { get; private set; }
    public Type ObjectType { get; private set; }

    public ContractCreatedEventArgs(JsonContract contract, Type objectType)
    {
        this.Contract = contract;
        this.ObjectType = objectType;
    }
}

public static class ConfigurableContractResolverExtensions
{
    public static ConfigurableContractResolver Configure(this ConfigurableContractResolver resolver, EventHandler<ContractCreatedEventArgs> handler)
    {
        if (resolver == null || handler == null)
            throw new ArgumentNullException();
        resolver.ContractCreated += handler;
        return resolver;
    }
}

接下来，创建一个扩展方法，将所需的属性添加到JsonObjectContract：

public static class JsonContractExtensions
{
    const string DatePropertiesName = "_date_properties_";

    public static void AddDateProperties(this JsonContract contract)
    {
        var objectContract = contract as JsonObjectContract;
        if (objectContract == null)
            return;
        var properties = objectContract.Properties.Where(p => p.PropertyType == typeof(DateTime) || p.PropertyType == typeof(DateTime?)).ToList();
        if (properties.Count > 0)
        {
            var property = new JsonProperty
            {
                DeclaringType = contract.UnderlyingType,
                PropertyName = DatePropertiesName,
                UnderlyingName = DatePropertiesName,
                PropertyType = typeof(string[]),
                ValueProvider = new FixedValueProvider(properties.Select(p => p.PropertyName).ToArray()),
                AttributeProvider = new NoAttributeProvider(),
                Readable = true,
                Writable = false,
                // Ensure // Ensure PreserveReferencesHandling and TypeNameHandling do not apply to the synthetic property.
                ItemIsReference = false, 
                TypeNameHandling = TypeNameHandling.None,
            };
            objectContract.Properties.Insert(0, property);
        }
    }

    class FixedValueProvider : IValueProvider
    {
        readonly object properties;

        public FixedValueProvider(object value)
        {
            this.properties = value;
        }

        #region IValueProvider Members

        public object GetValue(object target)
        {
            return properties;
        }

        public void SetValue(object target, object value)
        {
            throw new NotImplementedException("SetValue not implemented for fixed properties; set JsonProperty.Writable = false.");
        }

        #endregion
    }

    class NoAttributeProvider : IAttributeProvider
    {
        #region IAttributeProvider Members

        public IList<Attribute> GetAttributes(Type attributeType, bool inherit) { return new Attribute[0]; }

        public IList<Attribute> GetAttributes(bool inherit) { return new Attribute[0]; }

        #endregion
    }
}

最后，按如下方式序列化您的示例类型：

var settings = new JsonSerializerSettings
{
    ContractResolver = new ConfigurableContractResolver
    {
        // Here I am using CamelCaseNamingStrategy as is shown in your JSON.
        // If you don't want camel case, leave NamingStrategy null.
        NamingStrategy = new CamelCaseNamingStrategy(),
    }.Configure((s, e) => { e.Contract.AddDateProperties(); }),
};

var json = JsonConvert.SerializeObject(example, Formatting.Indented, settings);

此解决方案仅处理静态类型DateTime和DateTime?属性。如果您有object个有价值的属性，有时会有DateTime个值，或者Dictionary<string, DateTime>或extension data包含DateTime值，那么您需要一个更复杂的解决方案

（作为替代实现，你可以改为使用JsonContractExtensions.AddDateProperties()对DefaultContractResolver.CreateObjectContract进行子类化并使用'sklearn': ('http://scikit-learn.org/stable', (None, './_intersphinx/sklearn-objects.inv'))对所需的属性进行硬编码，但是我认为创建一个通用的，可流畅配置的合同解析器会更有趣如果以后需要插入不同的自定义项。）

您可能需要cache the contract resolver才能获得最佳效果。

示例.Net fiddle。

如何添加元数据来描述JSON.Net中哪些属性是日期

1 个答案: