/// <summary> /// Sets the list-type property on the <paramref name="target"/> object using the <see cref="JsonConverter"/> /// for collection items specified on the <paramref name="jsonProperty"/> (<see cref="JsonProperty.ItemConverter"/>). /// </summary> /// <param name="target">The target object being mapped.</param> /// <param name="jsonProperty">The property to populate.</param> /// <param name="token">The array containing the values to convert.</param> /// <param name="propertyContract"></param> /// <param name="serializer"></param> protected virtual void SetPropertyUsingItemConverter(object target, JsonProperty jsonProperty, JArray token, JsonContract propertyContract, JsonSerializer serializer) { var list = CreateNewList(propertyContract); if (list == null) { throw new JsonSerializationException( $"Unsupported property type {propertyContract.CreatedType.Name} when using ItemConverter with {nameof(JsonPathAttribute)}."); } using (var reader = token.CreateReader()) { // Advance reader to start of array reader.Read(); while (reader.Read() && reader.TokenType != JsonToken.EndArray) { list.Add(jsonProperty.ItemConverter.ReadJson(reader, jsonProperty.PropertyType, null, serializer)); } if (propertyContract.CreatedType.IsArray) { var array = (Array)Activator.CreateInstance(propertyContract.CreatedType, list.Count); list.CopyTo(array, 0); list = array; } SetPropertyValue(target, list, jsonProperty, serializer); } }
public override object ReadJson( JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { JObject eventsObject = JObject.Load(reader); Dictionary <EventType, AbstractSdkEventV1[]> eventsDictionary = new Dictionary <EventType, AbstractSdkEventV1[]>(); foreach (JProperty property in eventsObject.Properties()) { string eventName = property.Name; EventType eventType = (EventType)Enum.Parse(this._eventType, eventName, true); JToken eventValue = property.Value; JArray eventObject = JArray.Load(eventValue.CreateReader()); AbstractSdkEventV1[] eventsArray = (AbstractSdkEventV1[])serializer.Deserialize( eventObject.CreateReader(), this._arrayTypeMap[eventType] ); eventsDictionary.Add(eventType, eventsArray); } return(eventsDictionary); }
public override Dictionary <string, string> ReadJson( JsonReader reader, Type objectType, Dictionary <string, string> existingValue, bool hasExistingValue, JsonSerializer serializer) { if (reader.TokenType == JsonToken.StartArray) { existingValue = existingValue == null ? new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase) : new Dictionary <string, string>(existingValue, StringComparer.OrdinalIgnoreCase); JArray array = JArray.Load(reader); List <KeyValuePair <string, string> > target = new List <KeyValuePair <string, string> >(); serializer.Populate(array.CreateReader(), target); foreach (var item in target) { if (!existingValue.ContainsKey(item.Key)) { existingValue.Add(item.Key, item.Value); } } return(existingValue); } return(new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)); }
JsonReader Downloads() { // array-1 of array-2 where array-2 is package-id first element and remaining elements are 2 element array of version, downloads // e.g. [["package-a",["1.0",100],["2.0",150]],["package-b",["1.0",64],["2.0",128],["3.5",256]]] var downloads = new JArray(); return(downloads.CreateReader()); }
JsonReader Curatedfeeds() { // array-1 of array-2 where array-2 is feed-name first element and array of package-id second element // e.g. [["feed-x",["package-a","package-b"]],["feed-y,["package-a","package-b","package-c"]]] var curatedfeeds = new JArray(); return(curatedfeeds.CreateReader()); }
JsonReader Owners() { // array-1 of array-2 where array-2 is package-id first element and array of owners second element // e.g. [["package-a",["owner-x","owner-y"]],["package-b",["owner-z"]]] var owners = new JArray(); return(owners.CreateReader()); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { TransactionReceiptTrx transactionReceiptTrx = (TransactionReceiptTrx)value; JArray array = new JArray(); array.Add(JToken.Parse(transactionReceiptTrx.index.ToString())); array.Add(JToken.Parse(JsonConvert.SerializeObject(transactionReceiptTrx.trx))); writer.WriteToken(array.CreateReader()); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { JArray jsonArray = JArray.Load(reader); var deserialized = (List <T>)Activator.CreateInstance(typeof(List <T>)); serializer.Populate(jsonArray.CreateReader(), deserialized); return(deserialized as IList <I>); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { JArray jsonArray = JArray.Load(reader); var deserialized = (List <T>)Activator.CreateInstance(typeof(List <T>)); serializer.Populate(jsonArray.CreateReader(), deserialized); List <I> interfaceList = new List <I>(deserialized.Cast <I>()); if (interfaceList.Any()) { return(interfaceList); } return(null); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { try { if (reader.TokenType == JsonToken.Null) { return(null); } Type genericType = objectType.GetGenericArguments()[0]; // load jObject JArray jObject = JArray.Load(reader); // Create target object for Json => list of operations, typed to genericType var genericOperation = typeof(Operation <>); var concreteOperationType = genericOperation.MakeGenericType(genericType); var genericList = typeof(List <>); var concreteList = genericList.MakeGenericType(concreteOperationType); var targetOperations = Activator.CreateInstance(concreteList); //Create a new reader for this jObject, and set all properties to match the original reader. JsonReader jObjectReader = jObject.CreateReader(); jObjectReader.Culture = reader.Culture; jObjectReader.DateParseHandling = reader.DateParseHandling; jObjectReader.DateTimeZoneHandling = reader.DateTimeZoneHandling; jObjectReader.FloatParseHandling = reader.FloatParseHandling; // Populate the object properties serializer.Populate(jObjectReader, targetOperations); // container target: the typed JsonPatchDocument. var container = Activator.CreateInstance(objectType, targetOperations); return(container); } catch (Exception ex) { throw new JsonPatchException( new JsonPatchError(null, null, "The JsonPatchDocument was malformed and could not be parsed."), ex, 400); } }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { if (objectType != typeof(JsonPatchDocument)) { throw new ArgumentException("ObjectType must be of type JsonPatchDocument", "objectType"); } try { if (reader.TokenType == JsonToken.Null) { return(null); } // load jObject JArray jObject = JArray.Load(reader); // Create target object for Json => list of operations var targetOperations = new List <Operation>(); // Create a new reader for this jObject, and set all properties // to match the original reader. JsonReader jObjectReader = jObject.CreateReader(); jObjectReader.Culture = reader.Culture; jObjectReader.DateParseHandling = reader.DateParseHandling; jObjectReader.DateTimeZoneHandling = reader.DateTimeZoneHandling; jObjectReader.FloatParseHandling = reader.FloatParseHandling; // Populate the object properties serializer.Populate(jObjectReader, targetOperations); // container target: the JsonPatchDocument. var container = Activator.CreateInstance(objectType, targetOperations); return(container); } catch (Exception ex) { throw new JsonPatchException("The JsonPatchDocument was malformed and could not be parsed.", ex); } }
/// <summary> /// Read json and converts it. /// </summary> /// <param name="reader">Reader.</param> /// <param name="objectType">Object type.</param> /// <param name="existingValue">Existing value.</param> /// <param name="serializer">Serializer.</param> /// <returns></returns> public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { JArray jArray = null; if (reader.TokenType == JsonToken.StartArray) { jArray = JArray.Load(reader); } else { JObject jsonObject = JObject.Load(reader); JToken jToken = jsonObject.GetValue( "value", StringComparison.OrdinalIgnoreCase); if (null == jToken) { return(serializer.Deserialize(reader, objectType)); } jArray = jToken as JArray; } if (null == jArray) { return(serializer.Deserialize(reader, objectType)); } Type type = objectType.GetGenericArguments()[0]; Type listType = typeof(List <>); Type genericListType = listType.MakeGenericType(type); object instance = Activator.CreateInstance(genericListType); serializer.Populate( jArray.CreateReader(), instance); return(instance); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { List <IContent> result = new List <IContent>(); if (reader.TokenType == JsonToken.Null) { return(result); } JArray ja = JArray.Load(reader); //Create a new reader for this jObject, and set all properties to match the original reader. JsonReader jObjectReader = ja.CreateReader(); jObjectReader.Culture = reader.Culture; jObjectReader.DateParseHandling = reader.DateParseHandling; jObjectReader.DateTimeZoneHandling = reader.DateTimeZoneHandling; jObjectReader.FloatParseHandling = reader.FloatParseHandling; // Populate the object properties _serializer.Populate(jObjectReader, result); return(result); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { if (reader.TokenType == JsonToken.Null) { return(null); } if (reader.TokenType == JsonToken.StartObject) { var token = JToken.Load(reader); token = new JArray(token.SelectTokens("records[*].record")); using (var subReader = token.CreateReader()) { while (subReader.TokenType == JsonToken.None) { subReader.Read(); } return(base.ReadJson(subReader, objectType, existingValue, serializer)); // Use base class to convert } } else { return(base.ReadJson(reader, objectType, existingValue, serializer)); } }
private async Task <List <Meta> > ProcessMetaAsync(List <object> data) { bool codeValuesBlock = false; int i = 0; JArray tempJA = new JArray(); List <Meta> layerMeta = new List <Meta>(); StringBuilder sb = new StringBuilder(); StringWriter sw = new StringWriter(sb); JsonWriter writer = new JsonTextWriter(sw); try { JObject jObj = JsonUtils.MergeJSON <object>(data); tempJA = (JArray)jObj["fields"]; JsonReader reader = tempJA.CreateReader(); await writer.WriteStartArrayAsync(); while (reader.Read()) { if (codeValuesBlock == false) { if (reader.Value != null) { if (reader.TokenType == JsonToken.PropertyName) { if (reader.Value.ToString() == "domain") { codeValuesBlock = true; if (jObj["fields"][i]["domain"].HasValues) { var something = ""; try { something = jObj["fields"][i]["domain"]["codedValues"].ToString(); await writer.WritePropertyNameAsync("domain"); await writer.WriteRawValueAsync(something); await writer.WritePropertyNameAsync("range"); } catch (NullReferenceException e) { await writer.WritePropertyNameAsync("range"); something = jObj["fields"][i]["domain"]["range"].ToString(); await writer.WriteRawValueAsync(something); await writer.WritePropertyNameAsync("domain"); } await writer.WriteStartArrayAsync(); await writer.WriteEndArrayAsync(); await writer.WriteEndObjectAsync(); } else { await writer.WritePropertyNameAsync("domain"); await writer.WriteStartArrayAsync(); await writer.WriteEndArrayAsync(); await writer.WritePropertyNameAsync("range"); await writer.WriteStartArrayAsync(); await writer.WriteEndArrayAsync(); await writer.WriteEndObjectAsync(); codeValuesBlock = false; } i++; } else { if (reader.Value.ToString() == "name") { await writer.WriteStartObjectAsync(); } await writer.WritePropertyNameAsync(reader.Value.ToString()); } } else { await writer.WriteValueAsync(reader.Value.ToString()); } } } else { if (reader.Depth == 1) { codeValuesBlock = false; } } } await writer.WriteEndAsync(); layerMeta = JsonConvert.DeserializeObject <List <Meta> >(sw.ToString()); writer.Close(); } catch (Exception e) { writer.Close(); } //from appsettings.[env].json string[] excludesList = _config.GetSection("excludeFilters").Get <string[]>(); layerMeta = layerMeta.Where(m => !excludesList.Any(e => e.ToLower() == m.name.ToLower())).ToList(); return(layerMeta); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { object result = null; var jObj = serializer.Deserialize <JObject>(reader); if (jObj.ContainsKey("_type")) { //获取实际类型 var typeValue = jObj["_type"]; var type = Type.GetType(typeValue.ToString()); typeValue.Remove(); var typeReader = jObj.CreateReader(); //反序列化为实际类型 result = serializer.Deserialize(typeReader, type); } else { switch (jObj.Type) { case JTokenType.Array: //转换成JArray,数组最后一个为类型字符串 JArray arrayValue = JArray.Parse(jObj.ToString()); if (arrayValue.Count == 0) { throw new Exception("object Deserialize to array need typeinfo"); } var type = Type.GetType(arrayValue[arrayValue.Count - 1].ToString()); arrayValue.RemoveAt(arrayValue.Count - 1); var typeReader = arrayValue.CreateReader(); //反序列化为实际类型 result = serializer.Deserialize(typeReader, type); break; case JTokenType.Boolean: //反序列化为实际类型 result = serializer.Deserialize <bool>(reader); break; case JTokenType.Date: //反序列化为实际类型 result = serializer.Deserialize <DateTime>(reader); break; case JTokenType.Float: //反序列化为实际类型 result = serializer.Deserialize <decimal>(reader); break; case JTokenType.Guid: //反序列化为实际类型 result = serializer.Deserialize <Guid>(reader); break; case JTokenType.String: //反序列化为实际类型 result = serializer.Deserialize <string>(reader); break; case JTokenType.Integer: //反序列化为实际类型 result = serializer.Deserialize <int>(reader); break; default: result = null; break; } } return(result); }