在 C# 中使用 newtonsoft 查找并返回 JSON 差异？

Question

我想获取在使用 Newtonsoft 进行比较时不匹配的 JSON 部分的列表。

我有这段代码可以比较：

JObject xpctJSON = JObject.Parse(expectedJSON);
JObject actJSON = JObject.Parse(actualJSON);

bool res = JToken.DeepEquals(xpctJSON, actJSON);

但是找不到任何返回差异的东西。

Answer 1

只是为了帮助将来的查询。我遇到了一个不错的 json diff 工具。它完美地适用于 json 结构的差异/补丁：

jsondiffpatch.net 还有一个 nuget 包。

用法很简单。

var jdp = new JsonDiffPatch();
JToken diffResult = jdp.Diff(leftJson, rightJson);

Answer 2

这是我写的递归版本。您使用两个 JObject 调用 CompareObjects，它会返回差异列表。您用两个 JArrays 调用 CompareArrays 并比较数组。数组和对象可以相互嵌套。

更新：@nttakr 在下面的评论中指出，这种方法实际上是一种偏差算法。它仅从源列表的角度告诉您不同之处。如果源中不存在键但目标列表中存在键，则将忽略该差异。这是为我的测试要求而设计的。这允许您测试您想要的项目，而无需在比较完成之前将它们从目标中删除。

    /// <summary>
    /// Deep compare two NewtonSoft JObjects. If they don't match, returns text diffs
    /// </summary>
    /// <param name="source">The expected results</param>
    /// <param name="target">The actual results</param>
    /// <returns>Text string</returns>

    private static StringBuilder CompareObjects(JObject source, JObject target)
    {
        StringBuilder returnString = new StringBuilder();
        foreach (KeyValuePair<string, JToken> sourcePair in source)
        {
            if (sourcePair.Value.Type == JTokenType.Object)
            {
                if (target.GetValue(sourcePair.Key) == null)
                {
                    returnString.Append("Key " + sourcePair.Key
                                        + " not found" + Environment.NewLine);
                }
                else if (target.GetValue(sourcePair.Key).Type != JTokenType.Object) {
                    returnString.Append("Key " + sourcePair.Key
                                        + " is not an object in target" + Environment.NewLine);
                }                    
                else
                {
                    returnString.Append(CompareObjects(sourcePair.Value.ToObject<JObject>(),
                        target.GetValue(sourcePair.Key).ToObject<JObject>()));
                }
            }
            else if (sourcePair.Value.Type == JTokenType.Array)
            {
                if (target.GetValue(sourcePair.Key) == null)
                {
                    returnString.Append("Key " + sourcePair.Key
                                        + " not found" + Environment.NewLine);
                }
                else
                {
                    returnString.Append(CompareArrays(sourcePair.Value.ToObject<JArray>(),
                        target.GetValue(sourcePair.Key).ToObject<JArray>(), sourcePair.Key));
                }
            }
            else
            {
                JToken expected = sourcePair.Value;
                var actual = target.SelectToken(sourcePair.Key);
                if (actual == null)
                {
                    returnString.Append("Key " + sourcePair.Key
                                        + " not found" + Environment.NewLine);
                }
                else
                {
                    if (!JToken.DeepEquals(expected, actual))
                    {
                        returnString.Append("Key " + sourcePair.Key + ": "
                                            + sourcePair.Value + " !=  "
                                            + target.Property(sourcePair.Key).Value
                                            + Environment.NewLine);
                    }
                }
            }
        }
        return returnString;
    }

    /// <summary>
    /// Deep compare two NewtonSoft JArrays. If they don't match, returns text diffs
    /// </summary>
    /// <param name="source">The expected results</param>
    /// <param name="target">The actual results</param>
    /// <param name="arrayName">The name of the array to use in the text diff</param>
    /// <returns>Text string</returns>

    private static StringBuilder CompareArrays(JArray source, JArray target, string arrayName = "")
    {
        var returnString = new StringBuilder();
        for (var index = 0; index < source.Count; index++)
        {

            var expected = source[index];
            if (expected.Type == JTokenType.Object)
            {
                var actual = (index >= target.Count) ? new JObject() : target[index];
                returnString.Append(CompareObjects(expected.ToObject<JObject>(),
                    actual.ToObject<JObject>()));
            }
            else
            {

                var actual = (index >= target.Count) ? "" : target[index];
                if (!JToken.DeepEquals(expected, actual))
                {
                    if (String.IsNullOrEmpty(arrayName))
                    {
                        returnString.Append("Index " + index + ": " + expected
                                            + " != " + actual + Environment.NewLine);
                    }
                    else
                    {
                        returnString.Append("Key " + arrayName
                                            + "[" + index + "]: " + expected
                                            + " != " + actual + Environment.NewLine);
                    }
                }
            }
        }
        return returnString;
    }

Answer 3

我的解决方案是基于之前答案的想法：

public static JObject FindDiff(this JToken Current, JToken Model)
{
    var diff = new JObject();
    if (JToken.DeepEquals(Current, Model)) return diff;

    switch(Current.Type)
    {
        case JTokenType.Object:
            {
                var current = Current as JObject;
                var model = Model as JObject;
                var addedKeys = current.Properties().Select(c => c.Name).Except(model.Properties().Select(c => c.Name));
                var removedKeys = model.Properties().Select(c => c.Name).Except(current.Properties().Select(c => c.Name));
                var unchangedKeys = current.Properties().Where(c => JToken.DeepEquals(c.Value, Model[c.Name])).Select(c => c.Name);
                foreach (var k in addedKeys)
                {
                    diff[k] = new JObject
                    {
                        ["+"] = Current[k]
                    };
                }
                foreach (var k in removedKeys)
                {
                    diff[k] = new JObject
                    {
                        ["-"] = Model[k]
                    };
                }
                var potentiallyModifiedKeys = current.Properties().Select(c => c.Name).Except(addedKeys).Except(unchangedKeys);
                foreach (var k in potentiallyModifiedKeys)
                {
                    var foundDiff = FindDiff(current[k], model[k]);
                    if(foundDiff.HasValues) diff[k] = foundDiff;
                }
            }
            break;
        case JTokenType.Array:
            {
                var current = Current as JArray;
                var model = Model as JArray;
                var plus = new JArray(current.Except(model, new JTokenEqualityComparer()));
                var minus = new JArray(model.Except(current, new JTokenEqualityComparer()));
                if (plus.HasValues) diff["+"] = plus;
                if (minus.HasValues) diff["-"] = minus;
            }
            break;
        default:
            diff["+"] = Current;
            diff["-"] = Model;
            break;
    }

    return diff;
}

Answer 4

这是一个相对较老的问题，但发布了解决此问题的一种可能方法，假设您想要的结果正是更改了哪些属性值

   string sourceJsonString = "{'name':'John Doe','age':'25','hitcount':34}";
   string targetJsonString = "{'name':'John Doe','age':'26','hitcount':30}";

   JObject sourceJObject = JsonConvert.DeserializeObject<JObject>(sourceJsonString);
   JObject targetJObject = JsonConvert.DeserializeObject<JObject>(targetJsonString);

   if (!JToken.DeepEquals(sourceJObject, targetJObject))
   {
     foreach (KeyValuePair<string, JToken> sourceProperty in sourceJObject)
     {
         JProperty targetProp = targetJObject.Property(sourceProperty.Key);

          if (!JToken.DeepEquals(sourceProperty.Value, targetProp.Value))
          {
              Console.WriteLine(string.Format("{0} property value is changed", sourceProperty.Key));
          }
          else
          {
              Console.WriteLine(string.Format("{0} property value didn't change", sourceProperty.Key));
          }
      }
   }
   else
   {
      Console.WriteLine("Objects are same");
   }  

注意：这尚未针对非常深的层次结构进行测试。

Answer 5

注意以下库：

using System.Linq;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

我不完全确定我是否正确理解了您的问题。 我假设您正在尝试确定实际 JSON 中缺少哪些键。

如果您只是对缺少的 KEYS 感兴趣，下面的代码将对您有所帮助，如果没有，请提供您尝试识别的差异类型的示例。

  public IEnumerable<JProperty> DoCompare(string expectedJSON, string actualJSON)
    {
        // convert JSON to object
        JObject xptJson = JObject.Parse(expectedJSON);
        JObject actualJson = JObject.Parse(actualJSON);

        // read properties
        var xptProps = xptJson.Properties().ToList();
        var actProps = actualJson.Properties().ToList();

        // find missing properties
        var missingProps = xptProps.Where(expected => actProps.Where(actual => actual.Name == expected.Name).Count() == 0);

        return missingProps;
    }

请注意，如果此方法返回空 IEnumerable，则 ACTUAL JSON 具有根据预期 JSON 的结构所需的所有键。

注意：实际的 JSON 可能仍具有预期 JSON 不需要的更多键。

进一步解释我的笔记...

假设您预期的 JSON 是：

{ Id: 1, Name: "Item One", Value: "Sample" }

并且您的实际 JSON 是：

{ Id: 1, Name: "Item One", SomeProp: "x" }

上面的函数会告诉你缺少 Value 键，但不会提及 SomeProp 键的任何内容......除非你交换输入参数。

Answer 6

这是一个非常古老的线程，但是由于几个月前我来这里寻找可靠的工具但找不到，我已经编写了自己的，如果你正在寻找类似的东西，你可以使用它以下：

JSON 1

{
  "name":"John",
  "age":30,
  "cars": {
    "car1":"Ford",
    "car2":"BMW",
    "car3":"Fiat"
  }
 }

JSON 2

{
  "name":"John",
  "cars": {
    "car1":"Ford",
    "car2":"BMW",
    "car3":"Audi",
    "car4":"Jaguar"
  }
 }

用法

 var j1 = JToken.Parse(Read(json1));
 var j2 = JToken.Parse(Read(json2));

 var diff = JsonDifferentiator.Differentiate(j1,j2);

结果

{
  "-age": 30,
  "*cars": {
    "*car3": "Fiat",
    "+car4": "Jaguar"
  }
}

随时查看源代码并查看测试，欢迎您的反馈:)

https://www.nuget.org/packages/JsonDiffer

Answer 7

这里没有一个答案是我所需要的。

这是一个方法，它为比较的两个对象中的每一个返回一个 JObject。 JObject 仅包含不同的属性。这对于扫描对实体的更改并存储前后快照（序列化 JObject）很有用。

注意：更改扫描仅发生在顶级属性上。

        private Tuple<JObject, JObject> GetDeltaState<TRead>(TRead before, TRead after)
    {
        if (before == null && after == null)
            return new Tuple<JObject, JObject>(null, null);

        JObject beforeResult;
        JObject afterResult;

        // If one record is null then we don't need to scan for changes
        if (before == null ^ after == null)
        {
            beforeResult = before == null ? null : JObject.FromObject(before, _jsonSerializer);
            afterResult = after == null ? null : JObject.FromObject(after, _jsonSerializer);

            return new Tuple<JObject, JObject>(beforeResult, afterResult);
        }

        beforeResult = new JObject();
        afterResult = new JObject();

        JObject beforeState = JObject.FromObject(before, _jsonSerializer);
        JObject afterState = JObject.FromObject(after, _jsonSerializer);

        // Get unique properties from each object
        IEnumerable<JProperty> properties = beforeState.Properties().Concat(afterState.Properties()).DistinctBy(x => x.Name);

        foreach (JProperty prop in properties)
        {
            JToken beforeValue = beforeState[prop.Name];
            JToken afterValue = afterState[prop.Name];

            if (JToken.DeepEquals(beforeValue, afterValue))
                continue;

            beforeResult.Add(prop.Name, beforeValue);
            afterResult.Add(prop.Name, afterValue);
        }

        return new Tuple<JObject, JObject>(beforeResult, afterResult);
    }

Answer 8

我已经转换为更准确的对象数组

public static JObject FindDiff(this JToken leftJson, JToken rightJson)
{
    var difference = new JObject();
    if (JToken.DeepEquals(leftJson, rightJson)) return difference;

    switch (leftJson.Type) {
        case JTokenType.Object:
            {
                var LeftJSON = leftJson as JObject;
                var RightJSON = rightJson as JObject;
                var RemovedTags = LeftJSON.Properties().Select(c => c.Name).Except(RightJSON.Properties().Select(c => c.Name));
                var AddedTags = RightJSON.Properties().Select(c => c.Name).Except(LeftJSON.Properties().Select(c => c.Name));
                var UnchangedTags = LeftJSON.Properties().Where(c => JToken.DeepEquals(c.Value, RightJSON[c.Name])).Select(c => c.Name);
                foreach(var tag in RemovedTags)
                {
                    difference[tag] = new JObject
                    {
                        ["-"] = LeftJSON[tag]
                    };
                }
                foreach(var tag in AddedTags)
                {
                    difference[tag] = new JObject
                    {
                        ["-"] = RightJSON[tag]
                    };
                }
                var ModifiedTags = LeftJSON.Properties().Select(c => c.Name).Except(AddedTags).Except(UnchangedTags);
                foreach(var tag in ModifiedTags)
                {
                    var foundDifference = Compare(LeftJSON[tag], RightJSON[tag]);
                    if (foundDifference.HasValues) {
                        difference[tag] = foundDifference;
                    }
                }
            }
            break;
        case JTokenType.Array:
            {
                var LeftArray = leftJson as JArray;
                var RightArray = rightJson as JArray;

                if (LeftArray != null && RightArray != null) {
                    if (LeftArray.Count() == RightArray.Count()) {
                        for (int index = 0; index < LeftArray.Count(); index++)
                        {
                            var foundDifference = Compare(LeftArray[index], RightArray[index]);
                            if (foundDifference.HasValues) {
                                difference[$"{index}"] = foundDifference;
                            }
                        }
                    }
                    else {
                        var left = new JArray(LeftArray.Except(RightArray, new JTokenEqualityComparer()));
                        var right = new JArray(RightArray.Except(LeftArray, new JTokenEqualityComparer()));
                        if (left.HasValues) {
                            difference["-"] = left;
                        }
                        if (right.HasValues) {
                            difference["+"] = right;
                        }
                    }
                }
            }
            break;
        default:
            difference["-"] = leftJson;
            difference["+"] = rightJson;
            break;
    }

    return difference;
}

Answer 9

    public static void Validate(JToken actual, JToken expected, IList<string> diffMessages)
    {
        if (actual == null && expected == null)
        {
            // handle accroding to requirement
            return;
        }

        if (actual == null)
        {
            diffMessages.Add($"Diff on {expected.Path}: actual - null, expected - {expected}");
            return;
        }

        if (expected == null)
        {
            diffMessages.Add($"Diff on {actual.Path}: actual - {actual}, expected - null");
            return;
        }

        if (actual.Type != JTokenType.Object && actual.Type != JTokenType.Array && actual.Type != JTokenType.Property)
        {
            if (!JToken.DeepEquals(actual, expected))
            {
                diffMessages.Add($"Diff on {actual.Path}: actual- {actual}, expected - {expected}");
            }

            return;
        }


        // recursion

        foreach (var jItem in actual)
        {
            var newExpected = expected.Root.SelectToken(jItem.Path);
            Validate(jItem, newExpected, diffMessages);
        }

    }