使用 JSON 补丁向字典添加值
Using JSON Patch to add values to a dictionary
概述
我正在尝试使用 ASP.NET 核心编写 Web 服务,允许客户端查询和修改微控制器的状态。这个微控制器包含许多我在我的应用程序中建模的系统——例如,PWM 系统、执行器输入系统等。
这些系统的组件都有特定的属性,可以使用JSON patch request. For example, the 4th PWM on the micro can be enabled using an HTTP request carrying {"op":"replace", "path":"/pwms/3/enabled", "value":true}
. To support this, I'm using the AspNetCore.JsonPatch
库查询或修改这些属性。
我的问题 是我正在尝试实现 JSON 对新 "CAN database" 系统的补丁支持,逻辑上应该将定义名称映射到特定的 CAN 消息定义,我不确定该怎么做。
详情
下图模拟了 CAN 数据库系统。 CanDatabase
实例在逻辑上应该包含 IDictionary<string, CanMessageDefinition>
.
形式的字典
为了支持创建新的消息定义,我的应用程序应该允许用户像这样发送 JSON 补丁请求:
{
"op": "add",
"path": "/candb/my_new_definition",
"value": {
"template": ["...", "..."],
"repeatRate": "...",
"...": "...",
}
}
在这里,my_new_definition
将定义定义 name,并且与 value
关联的对象应该反序列化为 CanMessageDefinition
对象。然后应该将其作为新的键值对存储在 CanDatabase
字典中。
问题是 path
应该指定一个 属性 路径 ,对于静态类型的对象来说,这将是......好吧,静态的(一个例外这是因为它允许引用 数组元素 例如 /pwms/3
如上所述)。
我试过的
一个。 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'.
乙。依靠动态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 补丁不知道要将 value
反序列化为什么,从而导致数据作为 JObject
而不是 CanMessageDefinition
:
存储在字典中
是否可以 'tell' JSON 补丁如何反序列化信息?也许类似于在 Definitions
?
上使用 JsonConverter
属性
[JsonProperty(PropertyName = "candb")]
[JsonConverter(...)]
public IDictionary<string, object> Definitions { get; }
总结
- 我需要支持 JSON 向字典添加值的补丁请求
- 我试过走纯静态路线,但失败了
- 我试过使用动态 JSON 补丁
- 这部分有效,但我的数据存储为
JObject
类型而不是预期类型
- 是否有一个属性(或其他技术)可以应用于我的 属性 以让它反序列化为正确的类型(不是匿名类型)?
由于似乎没有任何正式的方法可以做到这一点,我想出了一个临时解决方案™(阅读:一个效果很好的解决方案,所以我可能会永远保留它)。
为了让它看起来像 JSON 补丁处理 dictionary-like 操作,我创建了一个名为 DynamicDeserialisationStore
的 class,它继承自 DynamicObject
并使使用 JSON 补丁对动态对象的支持。
更具体地说,这个 class 覆盖了 TrySetMember
、TrySetIndex
、TryGetMember
等方法,本质上就像一个字典,除了它委托所有这些提供给其构造函数的回调操作。
实施
下面的代码提供了 DynamicDeserialisationStore
的实现。它实现了 IDictionary<string, object>
(这是签名 JSON 补丁需要使用动态对象)但我只实现了我需要的最少方法。
JSON补丁对动态对象的支持的问题在于它将属性设置为JObject
实例,即它不会像设置静态属性时那样自动执行反序列化,因为它可以' 推断类型。 DynamicDeserialisationStore
根据对象类型进行参数化,它将尝试自动尝试将这些 JObject
实例反序列化到它们被设置的时间。
class 接受回调来处理基本的字典操作,而不是维护内部字典本身,因为在我的 "real" 系统模型代码中我实际上并没有使用字典(出于各种原因) - 我只是让它看起来像客户那样。
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
}
测试
下面提供了此 class 的测试。我创建了一个模拟系统模型(见图)并对其执行各种 JSON 补丁操作。
代码如下:
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
}
例如,您可以将收到的 Json 反序列化为一个对象:
var dataDict = JsonConvert.DeserializeObject<Dictionary<string, object>>(json);
并对其进行迭代,将要修补的 KeyValuePair 的值转换并转换为目标类型 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 中执行此操作。干杯
概述
我正在尝试使用 ASP.NET 核心编写 Web 服务,允许客户端查询和修改微控制器的状态。这个微控制器包含许多我在我的应用程序中建模的系统——例如,PWM 系统、执行器输入系统等。
这些系统的组件都有特定的属性,可以使用JSON patch request. For example, the 4th PWM on the micro can be enabled using an HTTP request carrying {"op":"replace", "path":"/pwms/3/enabled", "value":true}
. To support this, I'm using the AspNetCore.JsonPatch
库查询或修改这些属性。
我的问题 是我正在尝试实现 JSON 对新 "CAN database" 系统的补丁支持,逻辑上应该将定义名称映射到特定的 CAN 消息定义,我不确定该怎么做。
详情
下图模拟了 CAN 数据库系统。 CanDatabase
实例在逻辑上应该包含 IDictionary<string, CanMessageDefinition>
.
为了支持创建新的消息定义,我的应用程序应该允许用户像这样发送 JSON 补丁请求:
{
"op": "add",
"path": "/candb/my_new_definition",
"value": {
"template": ["...", "..."],
"repeatRate": "...",
"...": "...",
}
}
在这里,my_new_definition
将定义定义 name,并且与 value
关联的对象应该反序列化为 CanMessageDefinition
对象。然后应该将其作为新的键值对存储在 CanDatabase
字典中。
问题是 path
应该指定一个 属性 路径 ,对于静态类型的对象来说,这将是......好吧,静态的(一个例外这是因为它允许引用 数组元素 例如 /pwms/3
如上所述)。
我试过的
一个。 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'.
乙。依靠动态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 补丁不知道要将 value
反序列化为什么,从而导致数据作为 JObject
而不是 CanMessageDefinition
:
是否可以 'tell' JSON 补丁如何反序列化信息?也许类似于在 Definitions
?
JsonConverter
属性
[JsonProperty(PropertyName = "candb")]
[JsonConverter(...)]
public IDictionary<string, object> Definitions { get; }
总结
- 我需要支持 JSON 向字典添加值的补丁请求
- 我试过走纯静态路线,但失败了
- 我试过使用动态 JSON 补丁
- 这部分有效,但我的数据存储为
JObject
类型而不是预期类型 - 是否有一个属性(或其他技术)可以应用于我的 属性 以让它反序列化为正确的类型(不是匿名类型)?
- 这部分有效,但我的数据存储为
由于似乎没有任何正式的方法可以做到这一点,我想出了一个临时解决方案™(阅读:一个效果很好的解决方案,所以我可能会永远保留它)。
为了让它看起来像 JSON 补丁处理 dictionary-like 操作,我创建了一个名为 DynamicDeserialisationStore
的 class,它继承自 DynamicObject
并使使用 JSON 补丁对动态对象的支持。
更具体地说,这个 class 覆盖了 TrySetMember
、TrySetIndex
、TryGetMember
等方法,本质上就像一个字典,除了它委托所有这些提供给其构造函数的回调操作。
实施
下面的代码提供了 DynamicDeserialisationStore
的实现。它实现了 IDictionary<string, object>
(这是签名 JSON 补丁需要使用动态对象)但我只实现了我需要的最少方法。
JSON补丁对动态对象的支持的问题在于它将属性设置为JObject
实例,即它不会像设置静态属性时那样自动执行反序列化,因为它可以' 推断类型。 DynamicDeserialisationStore
根据对象类型进行参数化,它将尝试自动尝试将这些 JObject
实例反序列化到它们被设置的时间。
class 接受回调来处理基本的字典操作,而不是维护内部字典本身,因为在我的 "real" 系统模型代码中我实际上并没有使用字典(出于各种原因) - 我只是让它看起来像客户那样。
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
}
测试
下面提供了此 class 的测试。我创建了一个模拟系统模型(见图)并对其执行各种 JSON 补丁操作。
代码如下:
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
}
例如,您可以将收到的 Json 反序列化为一个对象:
var dataDict = JsonConvert.DeserializeObject<Dictionary<string, object>>(json);
并对其进行迭代,将要修补的 KeyValuePair 的值转换并转换为目标类型 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 中执行此操作。干杯