Wie kann ich JSON in ein einfaches Dictionary<string,string> in ASP.NET deserialisieren?

Question

Ich habe eine einfache Schlüssel/Wert-Liste in JSON, die über POST an ASP.NET zurückgesendet wird. Beispiel:

{ "key1": "value1", "key2": "value2"}

ICH VERSUCHE NICHT, IN STARK GETYPTE .NET-OBJEKTE ZU DESERIALISIEREN

Ich brauche einfach einen einfachen alten Dictionary(Of String, String) oder ein Äquivalent (Hash-Tabelle, Dictionary(Of String, Object), StringDictionary der alten Schule - ein 2-D-Array von Strings würde für mich funktionieren.

Ich kann alles verwenden, was in ASP.NET 3.5 verfügbar ist, ebenso wie das beliebte Json.NET (das ich bereits für die Serialisierung verwende) zu den Kunden).

Offensichtlich keine dieser JSON-Bibliotheken haben diese Stirn schlagen offensichtliche Fähigkeit out of the box--sie sind völlig auf Reflexion-basierte Deserialisierung über starke Verträge konzentriert.

Irgendwelche Ideen?

Beschränkungen:

1. Ich möchte nicht meinen eigenen JSON-Parser implementieren
2. ASP.NET 4.0 kann noch nicht verwendet werden
3. Ich würde es vorziehen, von der älteren, veralteten ASP.NET-Klasse für JSON wegzubleiben.

Answer 1

Mark Rendle hat dies veröffentlicht als Kommentar Ich wollte es als Antwort posten, da es die einzige Lösung ist, die bisher funktioniert hat, um die Erfolgs- und Fehlercodes json-Ergebnisse aus der Google reCaptcha-Antwort zurückzugeben.

string jsonReponseString= wClient.DownloadString(requestUrl);    
IDictionary<string, object> dict = new JavaScriptSerializer().DeserializeObject(jsonReponseString) as IDictionary<string, object>;

Nochmals vielen Dank, Mark!

Answer 2

Ich habe den von jSnake04 und Dasun eingereichten Code hier ergänzt. Ich habe Code hinzugefügt, um Listen von Objekten aus JArray Instanzen. Es verfügt über eine Zwei-Wege-Rekursion, aber da es mit einem festen, endlichen Baummodell arbeitet, besteht kein Risiko eines Stapelüberlaufs, es sei denn, die Daten sind sehr umfangreich.

/// <summary>
/// Deserialize the given JSON string data (<paramref name="data"/>) into a
///   dictionary.
/// </summary>
/// <param name="data">JSON string.</param>
/// <returns>Deserialized dictionary.</returns>
private IDictionary<string, object> DeserializeData(string data)
{
    var values = JsonConvert.DeserializeObject<Dictionary<string, object>>(data);

    return DeserializeData(values);
}

/// <summary>
/// Deserialize the given JSON object (<paramref name="data"/>) into a dictionary.
/// </summary>
/// <param name="data">JSON object.</param>
/// <returns>Deserialized dictionary.</returns>
private IDictionary<string, object> DeserializeData(JObject data)
{
    var dict = data.ToObject<Dictionary<String, Object>>();

    return DeserializeData(dict);
}

/// <summary>
/// Deserialize any elements of the given data dictionary (<paramref name="data"/>) 
///   that are JSON object or JSON arrays into dictionaries or lists respectively.
/// </summary>
/// <param name="data">Data dictionary.</param>
/// <returns>Deserialized dictionary.</returns>
private IDictionary<string, object> DeserializeData(IDictionary<string, object> data)
{
    foreach (var key in data.Keys.ToArray()) 
    {
        var value = data[key];

        if (value is JObject)
            data[key] = DeserializeData(value as JObject);

        if (value is JArray)
            data[key] = DeserializeData(value as JArray);
    }

    return data;
}

/// <summary>
/// Deserialize the given JSON array (<paramref name="data"/>) into a list.
/// </summary>
/// <param name="data">Data dictionary.</param>
/// <returns>Deserialized list.</returns>
private IList<Object> DeserializeData(JArray data)
{
    var list = data.ToObject<List<Object>>();

    for (int i = 0; i < list.Count; i++)
    {
        var value = list[i];

        if (value is JObject)
            list[i] = DeserializeData(value as JObject);

        if (value is JArray)
            list[i] = DeserializeData(value as JArray);
    }

    return list;
}

Answer 3

Ich habe der anderen Antwort eine Prüfung auf Nullwerte im JSON hinzugefügt

Ich hatte dasselbe Problem, also habe ich das selbst geschrieben. Diese Lösung ist unterscheidet sich von anderen Antworten, weil sie in mehrere Ebenen.

Senden Sie einfach einen json-String an deserializeToDictionary Funktion es gibt nicht stark typisierte Dictionary<string, object> Objekt.

private Dictionary<string, object> deserializeToDictionary(string jo)
{
    var values = JsonConvert.DeserializeObject<Dictionary<string, object>>(jo);
    var values2 = new Dictionary<string, object>();
    foreach (KeyValuePair<string, object> d in values)
    {
        if (d.Value != null && d.Value.GetType().FullName.Contains("Newtonsoft.Json.Linq.JObject"))
        {
            values2.Add(d.Key, deserializeToDictionary(d.Value.ToString()));
        }
        else
        {
            values2.Add(d.Key, d.Value);
        }
    }
    return values2;
}

Beispiel: Dies ergibt Dictionary<string, object> Objekt einer Facebook JSON-Antwort.

private void button1_Click(object sender, EventArgs e)
{
    string responsestring = "{\"id\":\"721055828\",\"name\":\"Dasun Sameera
        Weerasinghe\",\"first_name\":\"Dasun\",\"middle_name\":\"Sameera\",\"last_name\":\"Weerasinghe\",\"username\":\"dasun\",\"gender\":\"male\",\"locale\":\"en_US\",
        hometown: {id: \"108388329191258\", name: \"Moratuwa, Sri Lanka\",}}";
    Dictionary<string, object> values = deserializeToDictionary(responsestring);
}

Hinweis: Die Heimatstadt deserialisiert weiter in eine Dictionary<string, object> Objekt.

Answer 4

Hier ist meine Lösung mit System.Text.Json. Sie erhalten einen Json-String für die verschachtelten Objekte, die wiederum später in den benötigten Typ konvertiert werden können.

public static Dictionary<string,string> JsonToDictionary(this string json)
        {
            var objectValues = JsonSerializer.Deserialize<Dictionary<string, object>>(json);
            var stringValues = objectValues.Select(o => new KeyValuePair<string, string>(o.Key, o.Value?.ToString()));
            return stringValues.ToDictionary(pair => pair.Key, pair => pair.Value);
        }

Hier ist das Anwendungsbeispiel, um Werte aus einem verschachtelten Objekt zu holen:

 var result= json.JsonToDictionary()["outerField"]
                .JsonToDictionary()["innerField"];

Beachten Sie, dass diese Lösung nicht die json-Objekte abdeckt, die als Array beginnen, wie [12, 13]. Diese Objekte können zu Beginn als Array gelesen werden und dann kann die Erweiterungsmethode auf jedes Element angewendet werden, falls die Elemente komplexe Objekte mit eigenen Eigenschaften sind.

Answer 5

Auf der Grundlage von Kommentaren über Versuchen Sie JsonConvert.DeserializeObject<Dictionary<string,dynamic>>(json)

var json = @"{""key1"":1,""key2"":""value2"", ""object1"":{""property1"":""value1"",""property2"":[2,3,4,5,6,7]}}";
var parsedObject = JsonConvert.DeserializeObject<Dictionary<string,dynamic>>(json);

scheint auch bei komplexen Objekten und Listen zu funktionieren.