73

次のjson結果が与えられた場合：デフォルトのjson結果には、既知のフィールドのセットがあります。

{
    "id": "7908",
    "name": "product name"
}

ただし、結果を要求するときに名前がわからない追加のフィールド（この例では_unknown_field_name_1および）で拡張できます。_unknown_field_name_2

{
    "id": "7908",
    "name": "product name",
    "_unknown_field_name_1": "some value",
    "_unknown_field_name_2": "some value"
}

jsonの結果を、既知のフィールドのプロパティを持つクラスとの間でシリアル化および逆シリアル化し、未知のフィールド（プロパティがない）を辞書などのプロパティ（または複数のプロパティ）にマップして、次のようにできるようにします。アクセスおよび変更。

public class Product
{
    public string id { get; set; }
    public string name { get; set; }
    public Dictionary<string, string> fields { get; set; }
}

jsonシリアライザーにプラグインして、欠落しているメンバーのマッピングを自分で行う方法が必要だと思います（シリアル化と逆シリアル化の両方）。私はさまざまな可能性を見てきました：

  • json.netとカスタムコントラクトリゾルバー（その方法がわかりません）
  • datacontractシリアライザー（onserialized、onserializingのみをオーバーライドできます）
  • 動的にシリアル化し、カスタムマッピングを実行します（これは機能する可能性がありますが、多くの作業のようです）
  • DynamicObjectから継承する製品を許可します（シリアライザーはリフレクションで動作し、trygetmemberメソッドとtrysetmemberメソッドを呼び出さない）

レストシャープを使用していますが、どのシリアライザーも接続できます。

ああ、jsonの結果を変更することはできません。これも、これも役に立ちませんでした。

更新： これはより似ています：http：//geekswithblogs.net/DavidHoerster/archive/2011/07/26/json.net-custom-convertersndasha-quick-tour.aspx

4

5 に答える 5

101

この問題に取り組むためのさらに簡単なオプションは、 JSON.NETのJsonExtensionDataAttributeを使用することです。

public class MyClass
{
   // known field
   public decimal TaxRate { get; set; }

   // extra fields
   [JsonExtensionData]
   private IDictionary<string, JToken> _extraStuff;
}

こちらのプロジェクトブログにこのサンプルがあります

更新これにはJSON.NETv5リリース5以降が必要であることに注意してください

于 2014-02-13T19:38:27.663 に答える
9

https://gist.github.com/LodewijkSioen/5101814を参照してください

あなたが探していたのは習慣でしたJsonConverter

于 2013-03-06T18:37:57.503 に答える
4

これはあなたがそれを解決できる方法ですが、私はそれをあまり好きではありません。Newton/JSON.Netを使用して解決しました。逆シリアル化にもJsonConverterを使用できると思います。

private const string Json = "{\"id\":7908,\"name\":\"product name\",\"_unknown_field_name_1\":\"some value\",\"_unknown_field_name_2\":\"some value\"}";

    [TestMethod]
    public void TestDeserializeUnknownMembers()
    {
        var @object = JObject.Parse(Json);

        var serializer = new Newtonsoft.Json.JsonSerializer();
        serializer.MissingMemberHandling = Newtonsoft.Json.MissingMemberHandling.Error;
        serializer.Error += (sender, eventArgs) =>
            {
                var contract = eventArgs.CurrentObject as Contract ?? new Contract();
                contract.UnknownValues.Add(eventArgs.ErrorContext.Member.ToString(), @object[eventArgs.ErrorContext.Member.ToString()].Value<string>());
                eventArgs.ErrorContext.Handled = true;
            };

        using (MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(Json)))
        using (StreamReader streamReader = new StreamReader(memoryStream))
        using (JsonReader jsonReader = new JsonTextReader(streamReader))
        {
            var result = serializer.Deserialize<Contract>(jsonReader);
            Assert.IsTrue(result.UnknownValues.ContainsKey("_unknown_field_name_1"));
            Assert.IsTrue(result.UnknownValues.ContainsKey("_unknown_field_name_2"));
        }
    }

    [TestMethod]
    public void TestSerializeUnknownMembers()
    {
        var deserializedObject = new Contract
        {
            id = 7908,
            name = "product name",
            UnknownValues = new Dictionary<string, string>
        {
            {"_unknown_field_name_1", "some value"},
            {"_unknown_field_name_2", "some value"}
        }
        };

        var json = JsonConvert.SerializeObject(deserializedObject, new DictionaryConverter());
        Console.WriteLine(Json);
        Console.WriteLine(json);
        Assert.AreEqual(Json, json);
    }
}

class DictionaryConverter : JsonConverter
{
    public DictionaryConverter()
    {

    }

    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(Contract);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var contract = value as Contract;
        var json = JsonConvert.SerializeObject(value);
        var dictArray = String.Join(",", contract.UnknownValues.Select(pair => "\"" + pair.Key + "\":\"" + pair.Value + "\""));

        json = json.Substring(0, json.Length - 1) + "," + dictArray + "}";
        writer.WriteRaw(json);
    }
}

class Contract
{
    public Contract()
    {
        UnknownValues = new Dictionary<string, string>();
    }

    public int id { get; set; }
    public string name { get; set; }

    [JsonIgnore]
    public Dictionary<string, string> UnknownValues { get; set; }
}
}
于 2013-03-06T18:54:55.993 に答える
1

最近同じような問題があったので、帽子をリングに投げ込むと思いました。これが私が逆シリアル化したかったJSONの例です：

{
    "agencyId": "agency1",
    "overrides": {
        "assumption.discount.rates": "value: 0.07",
        ".plan": {
            "plan1": {
                "assumption.payroll.growth": "value: 0.03",
                "provision.eeContrib.rate": "value: 0.35"
            },
            "plan2": {
                ".classAndTier": {
                    "misc:tier1": {
                        "provision.eeContrib.rate": "value: 0.4"
                    },
                    "misc:tier2": {
                        "provision.eeContrib.rate": "value: 0.375"
                    }
                }
            }
        }
    }
}

これは、オーバーライドがさまざまなレベルで適用され、ツリーの下に継承されるシステム用です。いずれにせよ、私が望んでいたデータモデルは、これらの特別な継承ルールも提供されたプロパティバッグを持つことができるものでした。

私が最終的に得たのは次のとおりです。

public class TestDataModel
{
    public string AgencyId;
    public int Years;
    public PropertyBagModel Overrides;
}

public class ParticipantFilterModel
{
    public string[] ClassAndTier;
    public string[] BargainingUnit;
    public string[] Department;
}

public class PropertyBagModel
{
    [JsonExtensionData]
    private readonly Dictionary<string, JToken> _extensionData = new Dictionary<string, JToken>();

    [JsonIgnore]
    public readonly Dictionary<string, string> Values = new Dictionary<string, string>();

    [JsonProperty(".plan", NullValueHandling = NullValueHandling.Ignore)]
    public Dictionary<string, PropertyBagModel> ByPlan;

    [JsonProperty(".classAndTier", NullValueHandling = NullValueHandling.Ignore)]
    public Dictionary<string, PropertyBagModel> ByClassAndTier;

    [JsonProperty(".bargainingUnit", NullValueHandling = NullValueHandling.Ignore)]
    public Dictionary<string, PropertyBagModel> ByBarginingUnit;

    [OnSerializing]
    private void OnSerializing(StreamingContext context)
    {
        foreach (var kvp in Values)
            _extensionData.Add(kvp.Key, kvp.Value);
    }

    [OnSerialized]
    private void OnSerialized(StreamingContext context)
    {
        _extensionData.Clear();
    }

    [OnDeserialized]
    private void OnDeserialized(StreamingContext context)
    {
        Values.Clear();
        foreach (var kvp in _extensionData.Where(x => x.Value.Type == JTokenType.String))
            Values.Add(kvp.Key, kvp.Value.Value<string>());
        _extensionData.Clear();
    }
}

基本的な考え方は次のとおりです。

  1. JSON.NETによる逆シリアル化のPropertyBagModelには、ByPlan、ByClassAndTierなどのフィールドが入力されており、private_extensionDataフィールドも入力されています。
  2. 次に、JSON.NETはプライベートOnDeserialized（）メソッドを呼び出し、データを_extensionDataからValuesに適切に移動します（または、それ以外の場合はフロアにドロップします-おそらく、知りたい場合はこれをログに記録できます）。次に、_extensionDataから余分なガンクを削除して、メモリを消費しないようにします。
  3. シリアル化の際、OnSerializingメソッドは、データを_extensionDataに移動して保存する呼び出しを取得します。
  4. シリアル化が完了すると、OnSerializedが呼び出され、_extensionDataから余分なものが削除されます。

必要に応じて_extensionDataディクショナリをさらに削除して再作成することもできますが、これらのオブジェクトを大量に使用していないため、実際の値は表示されませんでした。これを行うには、OnSerializingで作成し、OnSerializedで削除します。OnDeserializingでは、クリアする代わりに、それを解放することができます。

于 2017-03-22T01:23:15.923 に答える
1

私は同様の問題を調べていて、この投稿を見つけました。

これは、リフレクションを使用してそれを行う方法です。

より一般的にするには、OFCのすべての実際のプロパティが文字列でない限り、propertyInfo.SetValueでToString（）を使用するのではなく、プロパティのタイプを確認する必要があります。

また、小文字のプロパティ名はC＃では標準ではありませんが、GetPropertyで大文字と小文字が区別されるため、他のオプションはほとんどありません。

public class Product
{
    private Type _type;

    public Product()
    {
        fields = new Dictionary<string, object>();
        _type = GetType();
    }

    public string id { get; set; }
    public string name { get; set; }
    public Dictionary<string, object> fields { get; set; }

    public void SetProperty(string key, object value)
    {
        var propertyInfo = _type.GetProperty(key);
        if (null == propertyInfo)
        {
            fields.Add(key,value);
            return;
        }
        propertyInfo.SetValue(this, value.ToString());
    }
}
...
private const string JsonTest = "{\"id\":7908,\"name\":\"product name\",\"_unknown_field_name_1\":\"some value\",\"_unknown_field_name_2\":\"some value\"}";

var product = new Product();
var data = JObject.Parse(JsonTest);
foreach (var item in data)
{
    product.SetProperty(item.Key, item.Value);
}
于 2018-01-04T09:18:04.923 に答える