使用 JSON Patch 将值添加到字典
Posted
技术标签:
【中文标题】使用 JSON Patch 将值添加到字典【英文标题】：Using JSON Patch to add values to a dictionary 【发布时间】：2017-05-31 11:39:41 【问题描述】：概述
我正在尝试使用 ASP.NET Core 编写一个 Web 服务，该服务允许客户端查询和修改微控制器的状态。该微控制器包含许多我在我的应用程序中建模的系统 - 例如，PWM 系统、执行器输入系统等。
这些系统的组件都有特定的属性，可以使用JSON patch 请求进行查询或修改。例如，可以使用携带"op":"replace", "path":"/pwms/3/enabled", "value":true 的HTTP 请求启用micro 上的第4 个PWM。为了支持这一点，我使用了AspNetCore.JsonPatch 库。
我的问题是我正在尝试为新的“CAN 数据库”系统实现 JSON 补丁支持，该系统在逻辑上应该将定义名称映射到特定的 CAN 消息定义，但我不是确定如何去做。
详情
下图模拟了 CAN 数据库系统。 CanDatabase 实例在逻辑上应该包含IDictionary<string, CanMessageDefinition> 形式的字典。
为了支持创建新的消息定义，我的应用程序应该允许用户像这样发送 JSON 补丁请求：
"op": "add",
"path": "/candb/my_new_definition",
"value":
"template": ["...", "..."],
"repeatRate": "...",
"...": "...",
这里，my_new_definition 将定义 name 定义，与 value 关联的对象应反序列化为 CanMessageDefinition object。然后应将其作为新的键值对存储在 CanDatabase 字典中。
问题是path 应该指定一个属性路径，对于静态类型的对象将是......好吧，静态（一个例外是它允许引用 数组元素 例如/pwms/3 同上）。
我尝试过的
A. Leeroy Jenkins 方法
忘记我知道它行不通的事实 - 我尝试了下面的实现（尽管我需要支持动态 JSON 补丁路径，但它只使用静态类型）只是为了看看发生。
实施
internal sealed class CanDatabaseModel : DeviceComponentModel<CanDatabaseModel>
public CanDatabaseModel()
this.Definitions = new Dictionary<string, CanMessageDefinition>();
[JsonProperty(PropertyName = "candb")]
public IDictionary<string, CanMessageDefinition> Definitions get;
...
测试
"op": "add",
"path": "/candb/foo",
"value":
"messageId": 171,
"template": [17, 34],
"repeatRate": 100,
"canPort": 0
结果
在我尝试将指定更改应用于JsonPatchDocument 的站点上抛出InvalidCastException。
网站：
var currentModelSnapshot = this.currentModelFilter(this.currentModel.Copy());
var snapshotWithChangesApplied = currentModelSnapshot.Copy();
diffDocument.ApplyTo(snapshotWithChangesApplied);
例外：
Unable to cast object of type 'Newtonsoft.Json.Serialization.JsonDictionaryContract' to type 'Newtonsoft.Json.Serialization.JsonObjectContract'.
B.依赖动态 JSON 补丁
一个更有希望的攻击计划似乎依赖于dynamic JSON patching，它涉及对ExpandoObject 的实例执行补丁操作。这允许您使用 JSON 补丁文档来添加、删除或替换属性，因为您正在处理动态类型的对象。
实施
internal sealed class CanDatabaseModel : DeviceComponentModel<CanDatabaseModel>
public CanDatabaseModel()
this.Definitions = new ExpandoObject();
[JsonProperty(PropertyName = "candb")]
public IDictionary<string, object> Definitions get;
...
测试
"op": "add",
"path": "/candb/foo",
"value":
"messageId": 171,
"template": [17, 34],
"repeatRate": 100,
"canPort": 0
结果
进行此更改允许我的这部分测试运行而不会引发异常，但 JSON Patch 不知道将 value 反序列化为什么，导致数据以 JObject 的形式存储在字典中，而不是一个CanMessageDefinition：
是否有可能“告诉”JSON Patch 如何反序列化信息？也许类似于在Definitions 上使用JsonConverter 属性？
[JsonProperty(PropertyName = "candb")]
[JsonConverter(...)]
public IDictionary<string, object> Definitions get;
总结
我需要支持向字典添加值的 JSON 补丁请求 我尝试过使用纯静态路由，但失败了 我尝试过使用动态 JSON 补丁 这部分有效，但我的数据存储为JObject 类型而不是预期类型
是否有一个属性（或其他一些技术）可以应用于我的属性以使其反序列化为正确的类型（不是匿名类型）？
【问题讨论】：
实现自定义 JSON 反序列化器看起来是一个可行的解决方案。您能否在value 对象中提供有关template 的更多详细信息？我们可以将messageId 和template 移动到父对象吗？
@Ankit template 表示 CAN 消息负载（0-8 字节），因此它是一个整数数组。 messageId 和 template 必须保持原样，因为请求需要遵守 RFC 6902 中所述的 JSON Patch 架构
你找到方法了吗？这是一个有趣的场景，我已将其添加为书签，以便在我下班后继续处理。
@Ankit 还没有。我正在使用临时解决方法（将PropertyChanged 事件处理程序注册到ExpandoObject 以手动将新的JObject 转换为CanMessageDefinition）。
Leeeeroooooooy！ :)
【参考方案1】：
由于似乎没有任何官方方法可以做到这一点，我想出了一个临时解决方案™（阅读：一个运行良好的解决方案，所以我可能会永远保留它）。
为了让 JSON Patch 看起来像处理类似字典的操作，我创建了一个名为 DynamicDeserialisationStore 的类，它继承自 DynamicObject 并利用 JSON Patch 对动态对象的支持。
更具体地说，这个类重写了 TrySetMember、TrySetIndex、TryGetMember 等方法，基本上就像字典一样，除了它将所有这些操作委托给提供给其构造函数的回调。
实施
下面的代码提供了DynamicDeserialisationStore的实现。它实现了IDictionary<string, object>（这是 JSON Patch 处理动态对象所需的签名），但我只实现了我需要的最低限度的方法。
JSON Patch 对动态对象的支持的问题在于它将属性设置为JObject 实例，即它不会像设置静态属性时那样自动执行反序列化，因为它无法推断类型。 DynamicDeserialisationStore 参数化对象的类型，它将尝试自动尝试将这些 JObject 实例反序列化到设置它们的时间。
该类接受回调来处理基本字典操作，而不是维护内部字典本身，因为在我的“真实”系统模型代码中，我实际上并没有使用字典（出于各种原因）——我只是让它看起来那样给客户。
internal sealed class DynamicDeserialisationStore<T> : DynamicObject, IDictionary<string, object> where T : class
private readonly Action<string, T> storeValue;
private readonly Func<string, bool> removeValue;
private readonly Func<string, T> retrieveValue;
private readonly Func<IEnumerable<string>> retrieveKeys;
public DynamicDeserialisationStore(
Action<string, T> storeValue,
Func<string, bool> removeValue,
Func<string, T> retrieveValue,
Func<IEnumerable<string>> retrieveKeys)
this.storeValue = storeValue;
this.removeValue = removeValue;
this.retrieveValue = retrieveValue;
this.retrieveKeys = retrieveKeys;
public int Count
get
return this.retrieveKeys().Count();
private IReadOnlyDictionary<string, T> AsDict
get
return (from key in this.retrieveKeys()
let value = this.retrieveValue(key)
select new key, value )
.ToDictionary(it => it.key, it => it.value);
public override bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value)
if (indexes.Length == 1 && indexes[0] is string && value is JObject)
return this.TryUpdateValue(indexes[0] as string, value);
return base.TrySetIndex(binder, indexes, value);
public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
if (indexes.Length == 1 && indexes[0] is string)
try
result = this.retrieveValue(indexes[0] as string);
return true;
catch (KeyNotFoundException)
// Pass through.
return base.TryGetIndex(binder, indexes, out result);
public override bool TrySetMember(SetMemberBinder binder, object value)
return this.TryUpdateValue(binder.Name, value);
public override bool TryGetMember(GetMemberBinder binder, out object result)
try
result = this.retrieveValue(binder.Name);
return true;
catch (KeyNotFoundException)
return base.TryGetMember(binder, out result);
private bool TryUpdateValue(string name, object value)
JObject jObject = value as JObject;
T tObject = value as T;
if (jObject != null)
this.storeValue(name, jObject.ToObject<T>());
return true;
else if (tObject != null)
this.storeValue(name, tObject);
return true;
return false;
object IDictionary<string, object>.this[string key]
get
return this.retrieveValue(key);
set
this.TryUpdateValue(key, value);
public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
return this.AsDict.ToDictionary(it => it.Key, it => it.Value as object).GetEnumerator();
public void Add(string key, object value)
this.TryUpdateValue(key, value);
public bool Remove(string key)
return this.removeValue(key);
#region Unused methods
bool ICollection<KeyValuePair<string, object>>.IsReadOnly
get
throw new NotImplementedException();
ICollection<string> IDictionary<string, object>.Keys
get
throw new NotImplementedException();
ICollection<object> IDictionary<string, object>.Values
get
throw new NotImplementedException();
void ICollection<KeyValuePair<string, object>>.Add(KeyValuePair<string, object> item)
throw new NotImplementedException();
void ICollection<KeyValuePair<string, object>>.Clear()
throw new NotImplementedException();
bool ICollection<KeyValuePair<string, object>>.Contains(KeyValuePair<string, object> item)
throw new NotImplementedException();
bool IDictionary<string, object>.ContainsKey(string key)
throw new NotImplementedException();
void ICollection<KeyValuePair<string, object>>.CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
throw new NotImplementedException();
IEnumerator IEnumerable.GetEnumerator()
throw new NotImplementedException();
bool ICollection<KeyValuePair<string, object>>.Remove(KeyValuePair<string, object> item)
throw new NotImplementedException();
bool IDictionary<string, object>.TryGetValue(string key, out object value)
throw new NotImplementedException();
#endregion
测试
下面提供了该类的测试。我创建了一个模拟系统模型（见图）并对其执行各种 JSON Patch 操作。
代码如下：
public class DynamicDeserialisationStoreTests
private readonly FooSystemModel fooSystem;
public DynamicDeserialisationStoreTests()
this.fooSystem = new FooSystemModel();
[Fact]
public void Store_Should_Handle_Adding_Keyed_Model()
// GIVEN the foo system currently contains no foos.
this.fooSystem.Foos.ShouldBeEmpty();
// GIVEN a patch document to store a foo called "test".
var request = "\"op\":\"add\",\"path\":\"/foos/test\",\"value\":\"number\":3,\"bazzed\":true";
var operation = JsonConvert.DeserializeObject<Operation<FooSystemModel>>(request);
var patchDocument = new JsonPatchDocument<FooSystemModel>(
new[] operation .ToList(),
new CamelCasePropertyNamesContractResolver());
// WHEN we apply this patch document to the foo system model.
patchDocument.ApplyTo(this.fooSystem);
// THEN the system model should now contain a new foo called "test" with the expected properties.
this.fooSystem.Foos.ShouldHaveSingleItem();
FooModel foo = this.fooSystem.Foos["test"] as FooModel;
foo.Number.ShouldBe(3);
foo.IsBazzed.ShouldBeTrue();
[Fact]
public void Store_Should_Handle_Removing_Keyed_Model()
// GIVEN the foo system currently contains a foo.
var testFoo = new FooModel Number = 3, IsBazzed = true ;
this.fooSystem.Foos["test"] = testFoo;
// GIVEN a patch document to remove a foo called "test".
var request = "\"op\":\"remove\",\"path\":\"/foos/test\"";
var operation = JsonConvert.DeserializeObject<Operation<FooSystemModel>>(request);
var patchDocument = new JsonPatchDocument<FooSystemModel>(
new[] operation .ToList(),
new CamelCasePropertyNamesContractResolver());
// WHEN we apply this patch document to the foo system model.
patchDocument.ApplyTo(this.fooSystem);
// THEN the system model should be empty.
this.fooSystem.Foos.ShouldBeEmpty();
[Fact]
public void Store_Should_Handle_Modifying_Keyed_Model()
// GIVEN the foo system currently contains a foo.
var originalFoo = new FooModel Number = 3, IsBazzed = true ;
this.fooSystem.Foos["test"] = originalFoo;
// GIVEN a patch document to modify a foo called "test".
var request = "\"op\":\"replace\",\"path\":\"/foos/test\", \"value\":\"number\":6,\"bazzed\":false";
var operation = JsonConvert.DeserializeObject<Operation<FooSystemModel>>(request);
var patchDocument = new JsonPatchDocument<FooSystemModel>(
new[] operation .ToList(),
new CamelCasePropertyNamesContractResolver());
// WHEN we apply this patch document to the foo system model.
patchDocument.ApplyTo(this.fooSystem);
// THEN the system model should contain a modified "test" foo.
this.fooSystem.Foos.ShouldHaveSingleItem();
FooModel foo = this.fooSystem.Foos["test"] as FooModel;
foo.Number.ShouldBe(6);
foo.IsBazzed.ShouldBeFalse();
#region Mock Models
private class FooModel
[JsonProperty(PropertyName = "number")]
public int Number get; set;
[JsonProperty(PropertyName = "bazzed")]
public bool IsBazzed get; set;
private class FooSystemModel
private readonly IDictionary<string, FooModel> foos;
public FooSystemModel()
this.foos = new Dictionary<string, FooModel>();
this.Foos = new DynamicDeserialisationStore<FooModel>(
storeValue: (name, foo) => this.foos[name] = foo,
removeValue: name => this.foos.Remove(name),
retrieveValue: name => this.foos[name],
retrieveKeys: () => this.foos.Keys);
[JsonProperty(PropertyName = "foos")]
public IDictionary<string, object> Foos get;
#endregion
【讨论】：
【参考方案2】：例如，您可以将收到的 Json 反序列化为一个对象：
var dataDict = JsonConvert.DeserializeObject<Dictionary<string, object>>(json);
并对其进行迭代，将要修补的 KeyValuePairs 的值转换为目标类型 CanMessageDefinition：
Dictionary<string, CanMessageDefinition> updateData = new Dictionary<string, CanMessageDefinition>();
foreach (var record in dataDict)
CanMessageDefinition recordValue = (CanMessageDefinition)record.Value;
if (yourExistingRecord.KeyAttributes.Keys.Contains(record.Key) && (!yourExistingRecord.KeyAttributes.Values.Equals(record.Value)))
updateData.Add(record.Key, recordValue);
只需将您的对象保存到您的数据库中。
如您所述，另一种方法是在 JsonConverter 中执行此操作。干杯
【讨论】：
以上是关于使用 JSON Patch 将值添加到字典的主要内容，如果未能解决你的问题，请参考以下文章