C# JObject.CreateReader方法代码示例

		private IElasticCoreType GetTypeFromJObject(JObject po, JsonSerializer serializer)
		{
			JToken typeToken;
			serializer.TypeNameHandling = TypeNameHandling.None;
			if (po.TryGetValue("type", out typeToken))
			{
				var type = typeToken.Value<string>().ToLowerInvariant();
				switch (type)
				{
					case "string":
						return serializer.Deserialize(po.CreateReader(), typeof(StringMapping)) as StringMapping;
					case "float":
					case "double":
					case "byte":
					case "short":
					case "integer":
					case "long":
						return serializer.Deserialize(po.CreateReader(), typeof(NumberMapping)) as NumberMapping;
					case "date":
						return serializer.Deserialize(po.CreateReader(), typeof(DateMapping)) as DateMapping;
					case "boolean":
						return serializer.Deserialize(po.CreateReader(), typeof(BooleanMapping)) as BooleanMapping;
					case "binary":
						return serializer.Deserialize(po.CreateReader(), typeof(BinaryMapping)) as BinaryMapping;
				}
			}
			return null;
		}

 public static EncryptedValuesReader FromObject(JObject encryptedValues)
 {
     var reader = encryptedValues.CreateReader();
     reader.Read();
     Debug.Assert(reader.TokenType == JsonToken.StartObject);
     reader.Read();
     return new EncryptedValuesReader(reader);
 }

 JsonReader Rankings()
 {
     //  object with a property "Rank" where the value of every property is an array of ids in decending order by download
     //  e.g. {"Rank":["package-a","package-b","package-c"]}
     var ranking = new JObject
     {
         "Rank", new JArray(),
     };
     return ranking.CreateReader();
 }

        //This json converter is used to map the actual names that are given in the CopernicaField attributes.
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            //TODO: Cleanup!

            // Load JObject from stream and get the data object, it's where the actual information is.
            JObject jObject = JObject.Load(reader);
            var data = jObject["data"];

            //If data is empty the REST api returned nothing
            if(data.FirstOrDefault() == null)
                throw new CopernicaException("Data is empty");

            //This part is needed when retrieving the fields in order to validate the given object.
            if (objectType.Name == "CopernicaField")
            {
                //Create a list of CopernicaField to return
                return data.Select(item => new CopernicaField(item["name"].ToString())
                {
                    //All we need to know is the Name, Length and Type to validate.
                    Length = item["length"] == null ? 0 : (int)item["length"],
                    Type = (string) item["type"]
                }).ToList();
            }

            //Parse the data until only the object is left.
            dynamic a = JObject.Parse(data.First.ToString());
            dynamic b = JObject.Parse(a["fields"].ToString());
            var obj = (Object)Activator.CreateInstance(objectType);
            var jobject = new JObject(b);

            //Get all the properties and loop trough them. Then add all the properties with the correct names from je object.
            //This makes sure the mapping is right when deserializing the object.
            var properties = objectType.GetProperties().Where(x => x.GetCustomAttributes(false).Any(y => y.GetType() == typeof(CopernicaField) || y.GetType() == typeof(CopernicaKeyField)));
            var jobj = new JObject();
            foreach (var property in properties)
            {
                jobj.Add(property.Name, jobject[property.GetCustomAttribute<CopernicaField>().Name]);
            }

            //Populate the correct data in the object.
            JsonReader objreader = jobj.CreateReader();
            serializer.Populate(objreader, obj);

            return obj;
        }

        public void Example()
        {
            #region Usage
            JObject o = new JObject
            {
                { "Cpu", "Intel" },
                { "Memory", 32 },
                {
                    "Drives", new JArray
                    {
                        "DVD",
                        "SSD"
                    }
                }
            };

            JsonReader reader = o.CreateReader();
            while (reader.Read())
            {
                Console.Write(reader.TokenType);
                if (reader.Value != null)
                {
                    Console.Write(" - " + reader.Value);
                }

                Console.WriteLine();
            }

            // StartObject
            // PropertyName - Cpu
            // String - Intel
            // PropertyName - Memory
            // Integer - 32
            // PropertyName - Drives
            // StartArray
            // String - DVD
            // String - SSD
            // EndArray
            // EndObject
            #endregion

            Assert.IsFalse(reader.Read());
        }

 private IElasticType GetTypeFromJObject(JObject po, JsonSerializer serializer)
 {
     JToken typeToken;
     serializer.TypeNameHandling = TypeNameHandling.None;
     if (po.TryGetValue("type", out typeToken))
     {
         var type = typeToken.Value<string>().ToLowerInvariant();
         switch (type)
         {
             case "string":
                 return serializer.Deserialize(po.CreateReader(), typeof(StringMapping)) as StringMapping;
             case "float":
             case "double":
             case "byte":
             case "short":
             case "integer":
             case "long":
                 return serializer.Deserialize(po.CreateReader(), typeof(NumberMapping)) as NumberMapping;
             case "date":
                 return serializer.Deserialize(po.CreateReader(), typeof(DateMapping)) as DateMapping;
             case "boolean":
                 return serializer.Deserialize(po.CreateReader(), typeof(BooleanMapping)) as BooleanMapping;
             case "binary":
                 return serializer.Deserialize(po.CreateReader(), typeof(BinaryMapping)) as BinaryMapping;
             case "object":
                 return serializer.Deserialize(po.CreateReader(), typeof(ObjectMapping)) as ObjectMapping;
             case "nested":
                 return serializer.Deserialize(po.CreateReader(), typeof(NestedObjectMapping)) as NestedObjectMapping;
             case "multi_field":
                 return serializer.Deserialize(po.CreateReader(), typeof(MultiFieldMapping)) as MultiFieldMapping;
             case "ip":
                 return serializer.Deserialize(po.CreateReader(), typeof(IPMapping)) as IPMapping;
             case "geo_point":
                 return serializer.Deserialize(po.CreateReader(), typeof(GeoPointMapping)) as GeoPointMapping;
             case "geo_shape":
                 return serializer.Deserialize(po.CreateReader(), typeof(GeoShapeMapping)) as GeoShapeMapping;
             case "attachment":
                 return serializer.Deserialize(po.CreateReader(), typeof(AttachmentMapping)) as AttachmentMapping;
         }
     }
     return null;
 }

			private static JsonReader CopyReaderForObject(JsonReader reader, JObject jObject)
			{
				var jObjectReader = jObject.CreateReader();
				jObjectReader.Culture = reader.Culture;
				jObjectReader.DateFormatString = reader.DateFormatString;
				jObjectReader.DateParseHandling = reader.DateParseHandling;
				jObjectReader.DateTimeZoneHandling = reader.DateTimeZoneHandling;
				jObjectReader.FloatParseHandling = reader.FloatParseHandling;
				jObjectReader.MaxDepth = reader.MaxDepth;
				jObjectReader.SupportMultipleContent = reader.SupportMultipleContent;
				return jObjectReader;
			}

        public void WriteEmptyToken()
        {
            JObject o = new JObject();
            JsonReader reader = o.CreateReader();
            while (reader.Read())
            {   
            }

            JTokenWriter writer = new JTokenWriter();

            writer.WriteStartArray();

            writer.WriteToken(reader);

            Assert.AreEqual(WriteState.Array, writer.WriteState);

            writer.WriteEndArray();

            StringAssert.AreEqual(@"[]", writer.Token.ToString());
        }

        public void WriteTokenWithParent()
        {
            JObject o = new JObject
            {
                ["prop1"] = new JArray(1),
                ["prop2"] = 1
            };

            JTokenWriter writer = new JTokenWriter();

            writer.WriteStartArray();

            writer.WriteToken(o.CreateReader());

            Assert.AreEqual(WriteState.Array, writer.WriteState);

            writer.WriteEndArray();

            Console.WriteLine(writer.Token.ToString());

            StringAssert.AreEqual(@"[
  {
    ""prop1"": [
      1
    ],
    ""prop2"": 1
  }
]", writer.Token.ToString());
        }

		private IDecayFunction ReadDecayFunction(string type, JObject o, JsonSerializer serializer)
		{
			var origin = o.Property("origin")?.Value.Type;
			if (origin == null) return null;
			var subType = "numeric";
			switch (origin)
			{
				case JTokenType.String:
					subType = "date";
					break;
				case JTokenType.Object:
					subType = "geo";
					break;
			}
			var t = DecayTypeMapping[$"{type}_{subType}"];
			return FromJson.Read(o.CreateReader(), t, null, serializer) as IDecayFunction;
		}

		private IElasticType GetTypeFromJObject(JObject po, JsonSerializer serializer)
		{
			JToken typeToken;
			JToken propertiesToken;
			JToken fieldsToken;
			var type = string.Empty;

			var hasType = po.TryGetValue("type", out typeToken);
			if (hasType)
				type = typeToken.Value<string>().ToLowerInvariant();
			else if (po.TryGetValue("properties", out propertiesToken))
				type = "object";

			var originalType = type;
			var hasFields = po.TryGetValue("fields", out fieldsToken);
			if (hasFields)
				type = "multi_field";

			serializer.TypeNameHandling = TypeNameHandling.None;

			switch (type)
			{
				case "string":
					return serializer.Deserialize(po.CreateReader(), typeof(StringMapping)) as StringMapping;
				case "float":
				case "double":
				case "byte":
				case "short":
				case "integer":
				case "long":
					return serializer.Deserialize(po.CreateReader(), typeof(NumberMapping)) as NumberMapping;
				case "date":
					return serializer.Deserialize(po.CreateReader(), typeof(DateMapping)) as DateMapping;
				case "boolean":
					return serializer.Deserialize(po.CreateReader(), typeof(BooleanMapping)) as BooleanMapping;
				case "binary":
					return serializer.Deserialize(po.CreateReader(), typeof(BinaryMapping)) as BinaryMapping;
				case "object":
					return serializer.Deserialize(po.CreateReader(), typeof(ObjectMapping)) as ObjectMapping;
				case "nested":
					return serializer.Deserialize(po.CreateReader(), typeof(NestedObjectMapping)) as NestedObjectMapping;
				case "multi_field":
					var m =serializer.Deserialize(po.CreateReader(), typeof(MultiFieldMapping)) as MultiFieldMapping;
					m.Type = originalType;
					return m;
				case "ip":
					return serializer.Deserialize(po.CreateReader(), typeof(IPMapping)) as IPMapping;
				case "geo_point":
					return serializer.Deserialize(po.CreateReader(), typeof(GeoPointMapping)) as GeoPointMapping;
				case "geo_shape":
					return serializer.Deserialize(po.CreateReader(), typeof(GeoShapeMapping)) as GeoShapeMapping;
				case "attachment":
					return serializer.Deserialize(po.CreateReader(), typeof(AttachmentMapping)) as AttachmentMapping;
			}

			return null;
		}

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            var currentResourceInstance = (IResource)Activator.CreateInstance(objectType);
            var jToken = JToken.ReadFrom(reader);
            if (jToken[ReservedPropertyNames.Relations] != null)
            {
                currentResourceInstance.Relations = serializer.Deserialize<Relations>(jToken[ReservedPropertyNames.Relations].CreateReader());
            }

            var simpleProperties =
                jToken.Where(_ => _.GetType() == typeof (JProperty))
                    .Cast<JProperty>()
                    .Where(_ => !ReservedPropertyNames.Names.Contains(_.Name));

            // Create a new JObject that will receive all "simple" non-reserved properties.
            // This will be the vehicle to populate the resource instance.
            var populater = new JObject();
            foreach (JProperty jProperty in simpleProperties)
            {
                populater.Add(jProperty);
            }

            serializer.Populate(populater.CreateReader(), currentResourceInstance);

            if (jToken[ReservedPropertyNames.EmbeddedResources] != null)
            {
                JToken embeddedResourceObject = jToken[ReservedPropertyNames.EmbeddedResources];
                foreach (var embeddedObjectProperty in embeddedResourceObject.Where(_ => _.GetType() == typeof(JProperty)).Cast<JProperty>())
                {
                    if (embeddedObjectProperty.Value.GetType() == typeof (JArray))
                    {
                        if (objectType.Name.ToLower().Contains(embeddedObjectProperty.Name))
                        {
                            var dynamicCurrent = (dynamic)currentResourceInstance;
                            var itemsProperty = objectType.GetProperty("Items");
                            var collectionResourceType = itemsProperty.PropertyType.GetGenericArguments().First();

                            // Recursion
                            foreach (var arrayElem in ((JArray) embeddedObjectProperty.Value))
                            {
                                var resourceElem =
                                    (IResource)
                                        serializer.Deserialize(arrayElem.CreateReader(), collectionResourceType);
                            
                                dynamicCurrent.AddItem(resourceElem);
                            }
                        }
                    }
                    else
                    {
                        var assignableProperty = objectType.GetProperties()
                            .Where(_ => typeof (IResource).IsAssignableFrom(_.PropertyType))
                            .FirstOrDefault(_ => _.PropertyType.Name.ToLower().Contains(embeddedObjectProperty.Name));
                        if (assignableProperty != null)
                        {
                            // Recursion
                            var resourceElem = serializer.Deserialize(embeddedObjectProperty.Value.CreateReader(),
                                assignableProperty.PropertyType);
                            assignableProperty.SetValue(currentResourceInstance, resourceElem);
                        }
                    }
                }
            }

            return currentResourceInstance;
        }

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            var depth = reader.Depth;

            string[] columns = null;

            var contract = (JsonArrayContract)serializer.ContractResolver.ResolveContract(objectType);

            object ret = existingValue;

            while (reader.Read() && reader.TokenType != JsonToken.EndObject && reader.Depth > depth)
            {
               while (reader.TokenType == JsonToken.PropertyName)
               {
                   var prop = (string)reader.Value;
                   if (prop == "columns")
                   {
                       reader.Read();
                       columns = serializer.Deserialize<string[]>(reader);
                   }
                   else if (prop == "data")
                   {
                       if (columns == null || columns.Length == 0)
                       {
                           reader.Skip();
                       }
                       else
                       {
                           //Deserialize the data part

                           if (existingValue == null)
                           {
                               if (contract.DefaultCreator != null)
                               {
                                   ret = contract.DefaultCreator();
                               }
                               else
                               {
                                   ret = Activator.CreateInstance(objectType);
                               }
                           }

                           var collectionItemType = contract.CollectionItemType;

                           var lst = (IList) ret;
                           if (!(reader.Read() && reader.TokenType == JsonToken.StartArray))
                           {
                               throw new Exception("Expected to read an array");
                           }

                           int arrayDepth = reader.Depth;
                           while (reader.Read() && (reader.TokenType != JsonToken.EndArray && reader.Depth >= arrayDepth))
                           {
                               //This is a row
                               var item = new JObject();

                               if (reader.TokenType != JsonToken.StartArray)
                                   throw new Exception("Expected to read an array but found " + reader.TokenType.ToString());

                               int index = 0;
                               int arrayDepth2 = reader.Depth;
                               while (reader.Read() &&
                                      (reader.TokenType != JsonToken.EndArray && reader.Depth >= arrayDepth2))
                               {
                                   item[columns[index]] = JToken.ReadFrom(reader);
                                   index++;
                               }

                               using (var subReader = item.CreateReader())
                               {
                                   lst.Add(serializer.Deserialize(subReader, collectionItemType));
                               }
                           }

                           if (reader.Depth > arrayDepth)
                               throw new JsonReaderException("Unexpected end of content while reading array.");
                       }
                   }
                   else
                   {
                       reader.Skip();
                   }
               }
            }

            return ret;
        }

        private static void InitObject(JsonSerializer serializer, object target, string href, JObject item)
        {
            var crestObject = (ICrestObject) target;
            crestObject.Href = href;

            serializer.Populate(item.CreateReader(), target);
            Task.Run(() => Crest.Settings.Cache.Put(crestObject));
        }