C# JsonReader.ReadValue方法代码示例

        public static object GetResultFromJson(string responseText)
        {
            var jsonReader = new JsonReader(responseText);

            if (responseText == string.Empty) return new JsonObject();

            dynamic result = jsonReader.ReadValue();
            return result;
        }

        object IJsonSerializable.Deserialize(JsonReader reader)
        {
            string property;
            while (reader.ReadProperty(out property))
            {
                switch (property)
                {
                    case "type":
                        Type = reader.ReadValue<string>();
                        break;
                    case "message":
                        Message = reader.ReadValue<string>();
                        break;
                    case "stackTrace":
                        StackTrace = reader.ReadValue<string>();
                        break;
                    case "url":
                        Url = reader.ReadValue<string>();
                        break;
                    case "refererUrl":
                        RefererUrl = reader.ReadValue<string>();
                        break;
                    case "additionalInfo":
                        AdditionalInfo = reader.ReadValue<Dictionary<string, object>>();
                        break;
                    default:
                        throw new ArgumentException("The specified property could not be deserialized.", property);
                }
            }

            return this;
        }

        public void JsonReader_Normal()
        {  
            string json = @"{ name: ""foo"",
description: ""hello me""}";

            using (var jsonReader = new JsonReader(json, false))
            {
                dynamic requestBodyJson = (IDictionary<string, object>)jsonReader.ReadValue();

                Assert.AreEqual("foo", requestBodyJson.name);

                Assert.AreEqual("hello me", requestBodyJson.description);
            }
        }

        public void TestReadValueObjectEmpty()
        {
            var jsonReader = new JsonReader("{}");

            object value = jsonReader.ReadValue();

            Assert.IsTrue(
                value is DynamicDictionary,
                "Value read is not a DynamicDictionary");

            var dictionary = value as DynamicDictionary;

            Assert.AreEqual(0, dictionary.Count);
        }

        public void JsonReader_InvalidFormat()
        {
            string json = "{ name: \"";

            using (var jsonReader = new JsonReader(json, false))
            {
                try
                {
                    jsonReader.ReadValue();
                    Assert.Fail("Expected FormatException to be thrown.");
                }
                catch (FormatException)
                {
                }
            }
        }

        protected override object ImportValue(JsonReader reader)
        {
            if (reader == null)
                throw new ArgumentNullException("reader");

            reader.ReadToken(JsonTokenClass.Object);
            
            object o = Activator.CreateInstance(OutputType);
            
            while (reader.TokenClass != JsonTokenClass.EndObject)
            {
                string memberName = reader.ReadMember();
               
                PropertyDescriptor property = _properties[memberName];
                
                if (property != null && !property.IsReadOnly)
                    property.SetValue(o, reader.ReadValue(property.PropertyType));
                else 
                    reader.Skip();
            }
         
            return o;
        }

        public void JsonReader_EscapedCharacters()
        {
            string json = "{" +
                "\"b\":\"\\b\"," +
                "\"t\":\"\\t\"," +
                "\"n\":\"\\n\"," +
                "\"f\":\"\\f\"," +
                "\"r\":\"\\r\"," +
                "\"q\":\"\\\"\"," +
                "\"rs\":\"\\\\\"" + "}";

            using (var jsonReader = new JsonReader(json, false))
            {
                dynamic requestBodyJson = (IDictionary<string, object>)jsonReader.ReadValue();

                Assert.AreEqual("\b", requestBodyJson.b);
                Assert.AreEqual("\t", requestBodyJson.t);
                Assert.AreEqual("\n", requestBodyJson.n);
                Assert.AreEqual("\f", requestBodyJson.f);
                Assert.AreEqual("\r", requestBodyJson.r);
                Assert.AreEqual("\"", requestBodyJson.q);
                Assert.AreEqual("\\", requestBodyJson.rs);
            }
        }

        public void TestReadInvalidJsonText()
        {
            var jsonReader = new JsonReader("klasdjfas89123;kja#!");

            try
            {
                jsonReader.ReadValue();
                Assert.Fail("Expected FormatException to be thrown.");
            }
            catch (FormatException)
            {
            }
        }

        public void TestReadInvalidJsonTextEmptyString()
        {
            var jsonReader = new JsonReader("");

            try
            {
                jsonReader.ReadValue();
                Assert.Fail("Expected FormatException to be thrown.");
            }
            catch (FormatException)
            {
            }
        }

        public void TestReadValueNull()
        {
            var jsonReader = new JsonReader("{ \"data\": null }");

            dynamic value = jsonReader.ReadValue();

            Assert.IsNull(value.data, "Expected Value read to be null");
        }

        public void TestReadValueBooleanFalse()
        {
            var jsonReader = new JsonReader("{ \"data\": false }");

            dynamic value = jsonReader.ReadValue();

            Assert.IsTrue(
                value.data is bool,
                "Value read is not a bool");

            Assert.AreEqual(false, (bool)value.data);
        }

        public void TestReadValueFloatWithExpentionalNotationNegative()
        {
            // ToString and Back loses some fidelity so we do it now
            // to be able to compare the return value from ReadValue
            float min = float.Parse(float.MinValue.ToString());
            var jsonReader = new JsonReader("{ \"data\": " + min.ToString() + " }");

            dynamic value = jsonReader.ReadValue();

            Assert.IsTrue(
                value.data is float,
                "Value read is not a float");

            Assert.AreEqual(min, (float)value.data);
        }

            public object Deserialize(JsonReader reader)
            {
                string property;
                while (reader.ReadProperty(out property))
                {
                    switch (property)
                    {
                        case "source":
                            Source = reader.ReadValue<ChangeSource>();
                            break;
                        case "changes":
                            Changes = reader.ReadValue<List<ModelEvent>>();
                            break;
                        default:
                            throw new ArgumentException("The specified property could not be deserialized.", property);
                    }
                }

                return this;
            }

            object IJsonSerializable.Deserialize(JsonReader reader)
            {
                ModelInstance instance = null;
                string eventName = null;
                string property;
                Type eventType = null;
                DomainEvent domainEvent = null;
                ModelMethod method = null;
                object[] methodArgs = null;

                while (reader.ReadProperty(out property))
                {
                    switch (property)
                    {
                        // Get the event target
                        case "instance":
                            instance = reader.ReadValue<ModelInstance>();
                            break;

                        // Get the property paths to include
                        case "include":
                            Include = reader.ReadValue<string[]>();
                            break;

                        // Get the type of event
                        case "type":
                            eventName = reader.ReadValue<string>();
                            break;

                        // Get the event data
                        case "event":
                            if (eventName != null && instance != null)
                                eventType = instance.Type.GetEventType(eventName);

                            // Deserialize the strongly-typed event
                            if (eventType != null)
                            {
                                // Create a generic event instance
                                domainEvent = (DomainEvent)typeof(DomainEvent<>)
                                    .MakeGenericType(eventType)
                                    .GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { eventType }, null)
                                    .Invoke(new object[] { reader.ReadValue(eventType) });

                                // Set the event target and inclusion paths
                                domainEvent.Instance = instance;
                                domainEvent.Include = Include;
                            }

                            // Otherwise, see if it is a model method invocation
                            else
                            {
                                var separator = eventName.LastIndexOf(".");
                                if (separator > 0)
                                {
                                    var type = ModelContext.Current.GetModelType(eventName.Substring(0, separator));
                                    var methodName = eventName.Substring(separator + 1);
                                    while (type != null && method == null)
                                    {
                                        method = type.Methods[methodName];
                                        type = type.BaseType;
                                    }

                                    if (method != null && reader.TokenType == Newtonsoft.Json.JsonToken.StartObject && reader.Read())
                                    {
                                        methodArgs = new object[method.Parameters.Count];

                                        string parameter;
                                        while (reader.ReadProperty(out parameter))
                                        {
                                            // Get the parameter with the specified name
                                            var p = method.Parameters.FirstOrDefault(pm => pm.Name == parameter);
                                            if (p == null)
                                                throw new ArgumentException("The parameter '" + property + "' is not valid for method '" + method.DeclaringType.Name + "." + method.Name + "'.");

                                            // Value type
                                            if (p.ReferenceType == null)
                                                methodArgs[p.Index] = reader.ReadValue(p.ParameterType);

                                            // List type
                                            else if (p.IsList)
                                                methodArgs[p.Index] = reader.ReadValue<ModelInstance[]>();

                                            // Reference type
                                            else
                                                methodArgs[p.Index] = reader.ReadValue<ModelInstance>();
                                        }
                                        reader.Read();
                                    }
                                }
                            }
                            break;

                        default:
                            throw new ArgumentException("The specified property could not be deserialized.", property);
                    }
                }

                // Custom domain event
                if (domainEvent != null)
                    return domainEvent;
//.........这里部分代码省略.........

        public void TestReadValueArrayEmpty()
        {
            var jsonReader = new JsonReader("[]");

            object value = jsonReader.ReadValue();

            Assert.IsTrue(
                value is List<object>,
                "Value read is not a List<object>");

            var list = value as List<object>;

            Assert.AreEqual(0, list.Count);
        }