C# JsonValue.Add方法代码示例

        static JsonValue ReadArray(string json, ref int i)
        {
            i++; // Skip the '['
            SkipWhitespace(json, ref i);

            JsonValue arrayval = new JsonValue();
            arrayval.Type = JsonType.Array;

            bool expectingValue = false;
            while (json[i] != ']') {
                expectingValue = false;
                arrayval.Add(ReadValue(json, ref i));
                SkipWhitespace(json, ref i);
                if (json[i] == ',') {
                    expectingValue = true;
                    i++;
                    SkipWhitespace(json, ref i);
                } else if (json[i] != ']') {
                    throw new InvalidJsonException("Expected end array token at column " + i + "!");
                }
            }

            if (expectingValue) {
                throw new InvalidJsonException("Unexpected end array token at column " + i + "!");
            }

            i++; // Skip the ']'
            return arrayval;
        }

    public void ArrayOperations()
    {
        JsonValue test = new JsonValue() { 1, 2, 3 };

        Assert.That(test.Count, Is.EqualTo(3));
        Assert.That(test.Contains(1), Is.True);
        Assert.That(test.Contains(4), Is.False);

        JsonValue[] values = new JsonValue[3];
        test.CopyTo(values, 0);
        for (int i = 0; i < 3; i++) {
            Assert.That((int)values[i], Is.EqualTo((int)test[i]));
        }

        test.Remove(2);
        Assert.That(test.Contains(1), Is.True);
        Assert.That(test.Contains(2), Is.False);
        Assert.That(test.Contains(3), Is.True);

        Assert.That(test.IsReadOnly, Is.False);

        Assert.That(test.IndexOf(1), Is.EqualTo(0));

        test.Insert(1, 2);
        Assert.That((int)test[1], Is.EqualTo(2));
        Assert.That(test.Count, Is.EqualTo(3));

        test.RemoveAt(1);
        Assert.That((int)test[1], Is.EqualTo(3));
        Assert.That(test.Count, Is.EqualTo(2));

        test.Clear();
        Assert.That(test.Count, Is.EqualTo(0));

        test.Add(5);
        Assert.That(test.Count, Is.EqualTo(1));
        Assert.That((int)test[0], Is.EqualTo(5));
    }

        static JsonValue ReadObject(string json, ref int i)
        {
            var obj = new JsonValue();
            obj.Type = JsonType.Object;
            i++; // Skip the '{'

            SkipWhitespace(json, ref i);
            if (json[i] != '}') {
                //ReadElements(obj, json, ref i);
                while (true) {
                    SkipWhitespace(json, ref i);

                    var key = ReadString(json, ref i);
                    SkipWhitespace(json, ref i);
                    if (json[i] != ':') {
                        throw new InvalidJsonException("Expected ':' at column " + i + "!");
                    }
                    ++i; // Skip the ':'
                    SkipWhitespace(json, ref i);
                    var value = ReadValue(json, ref i);
                    obj.Add((string)key, value);

                    SkipWhitespace(json, ref i);

                    if (json[i] == ',') {
                        i++; // Skip the ','
                    } else {
                        break;
                    }
                }
            }
            if (json[i] != '}') {
                throw new InvalidJsonException("Expected closing object token at column " + i + "!");
            }

            i++; // Skip the '}'

            return obj;
        }

    public void KVPCollection()
    {
        JsonValue test = new JsonValue() {
            {"one", 1},
            {"two", 2},
            {"three", 3},
        };

        test.Remove(new KeyValuePair<string, JsonValue>("one", 1));
        Assert.That(test.Count, Is.EqualTo(2));
        Assert.Throws<KeyNotFoundException>(() => test["one"].ToString());

        KeyValuePair<string, JsonValue>[] dest = new KeyValuePair<string, JsonValue>[2];
        test.CopyTo(dest, 0);
        for (int i = 0; i < 2; ++i) {
            Assert.That(test[dest[i].Key].Equals(dest[i].Value));
        }

        Assert.That(test.Contains(new KeyValuePair<string, JsonValue>("two", 2)));

        test.Add(new KeyValuePair<string, JsonValue>("four", 4));

        Assert.That(test.ContainsKey("four"), Is.True);
        Assert.That((int)test["four"], Is.EqualTo(4));
    }

    public void IDictionary()
    {
        JsonValue test = new JsonValue() {
            {"one", 1},
            {"two", 2},
            {"three", 3}
        };

        Assert.That((int)test["one"], Is.EqualTo(1));
        test["one"] = 5;
        Assert.That((int)test["one"], Is.EqualTo(5));
        test["one"] = 1;

        var keys = test.Keys;
        Assert.That(keys.Count, Is.EqualTo(3));
        Assert.That(keys.Contains("one"), Is.True);
        Assert.That(keys.Contains("two"), Is.True);
        Assert.That(keys.Contains("three"), Is.True);

        var values = test.Values;
        Assert.That(values.Count, Is.EqualTo(3));
        var intvalues = values.Select(x => (int)x).ToArray();
        Array.Sort(intvalues);
        for (int i = 0; i < 3; i++) {
            Assert.That(intvalues[i], Is.EqualTo(i + 1));
        }

        test.Add("four", 4);
        Assert.That(test.Count, Is.EqualTo(4));
        Assert.That((int)test["four"], Is.EqualTo(4));

        JsonValue val;
        Assert.That(test.TryGetValue("one", out val), Is.True);
        Assert.That((int)val, Is.EqualTo(1));
        Assert.That(test.TryGetValue("seven", out val), Is.False);
        Assert.That(val, Is.Null);

        Assert.That(test.ContainsKey("four"), Is.True);
        test.Remove("four");
        Assert.That(test.Count, Is.EqualTo(3));
        Assert.That(test.ContainsKey("four"), Is.False);
    }