C # объединить 2 строки Json

#c#

#c#

Вопрос:

Я попытался объединить 2 строки json, но, к сожалению, это работает не так, как ожидалось, потому что я хочу объединить эти 2 json-данные на основе id, как показано здесь ниже :

 Json_1 :
result [
        result[0]
              { id : 11111
                attribute1 : "<anything>"
                attribute2 : "<anything>"
                ...
              } 
        result[1]
              { id : 22222
                attribute1 : "<anything>"
                attribute2 : "<anything>"
                ...
              } 
        ...
      ]

Json_2 :
result [
        result[0]
              { id : 11111
                attribute99 : "<anything>"
                attribute98 : "<anything>"
                ...
              } 
        result[1]
              { id : 22222
                attribute99 : "<anything>"
                attribute98 : "<anything>"
                ...
              } 
        ...
]

Expect Merged Json should look like this :
Result[
           result[0]
              { id : 11111
                attribute1 : "<anything>"
                attribute2 : "<anything>"
                attribute99 : "<anything>"
                attribute98 : "<anything>"
                ...
              } 
        result[1]
              { id : 22222
                attribute1 : "<anything>"
                attribute2 : "<anything>"
                attribute99 : "<anything>"
                attribute98 : "<anything>"
                ...
              } 
        ...
]
 

Где атрибуты из Json_2 объединяются с атрибутами из Json_2 в соответствии с идентификатором каждого результирующего объекта в массиве.

может кто-нибудь помочь мне с кодом C # такого Слияния?

Обновить :

Спасибо за предоставленную помощь. То, что я делал до сих пор, — это функция, приведенная ниже, чтобы получить json_2, вложенный в json_1 в соответствии с каждым идентификатором. То, что я ищу, — это получить все ключи, значения, добавленные к свойствам json_1. Зная, что я не являюсь разработчиком pur с ограниченным опытом в C #.

     public static string MergeJson(string json1,string json2)
    {

        JObject obj_json_1 = JObject.Parse(json1);
        JObject obj_json_1 = JObject.Parse(json2);

        var lookup = obj_json_2.SelectTokens("result[*]").ToLookup(c => (string)c["id"]);

        foreach (var std in obj_json_1.SelectTokens("result[*]"))
        {
            try
            {
                std["result"] = (new JArray(lookup[(string)std["id"]]));
            }
            catch (Exception e)
            {
                Console.WriteLine("Error in Merge Json : {0}", e.Message);
            }
        }
        return obj_json_1.ToString();
    }
 

Комментарии:

1. Где находится код, с которым вам нужна помощь?

2. знаете ли вы, что ваш «JSON» даже близко не соответствует действительному JSON? также: что вы пробовали сами ? с какими проблемами вы столкнулись? что вы исследовали?

Ответ №1:

Вероятно, вы хотите объявить класс JSON следующим образом:

 class Result
{
    public List<Dictionary<string, string>> result
}
 

Затем вы можете получить два объекта с помощью Newtonsoft.Json, вот так:

 var result = JsonConvert.Deserialize<Result>(jsonA)?.result ?? new List<Dictionary<string, string>>;
var other = JsonConvert.Deserialize<Result>(jsonB)?.result ?? new List<Dictionary<string, string>>;
 

Затем вы можете объединить их последовательно, помните, что у нас может не быть определенного индекса, поэтому нам нужно создать объект там:

 result.Capacity = Math.Max(result.Count, other.Count);   //for better performance, can remove
for(var i = 0; i < other.Count; i  )
{
    if(result.Count < i)
        result.Add(new Dictionary<string, string>());
    if(result[i] == null)
        result[i] = new Dictionary<string, string>();
    result[i].Capacity = result[i].Count   other[i].Count;   //for better performance, can remove
    for each(var kvp in other[i])
        result[i][kvp.Key] = kvp.Value;
}
 

result теперь содержит объединенный результат.

Обратите внимание, что мы делаем предположение, что нет перекрывающихся ключей.