// Constructor public MainPage() { InitializeComponent(); this.webHybrid = new WebHybrid(this.webView, new JsonSerializer()); SaveFilesInHTMLFolderToIsoStore(); this.webView.Navigate(new Uri("HTML/home.html", UriKind.Relative)); //var fi = new FileInfo(@"./Assets/home.html"); //using (var streamReader = new StreamReader(fi.FullName)) //{ // this.webView.NavigateToString(streamReader.ReadToEnd()); //} this.webHybrid.RegisterCallback("test", s => { System.Diagnostics.Debug.WriteLine(s); var serializer = new JsonSerializer(); var m = serializer.Deserialize<ChartViewModel>(s); System.Diagnostics.Debug.WriteLine(m); }); this.webHybrid.RegisterCallback("dataCallback", s => System.Diagnostics.Debug.WriteLine(s)); }
/// <summary> /// Writes the JSON representation of the object. /// </summary> /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param> /// <param name="value">The value.</param> /// <param name="serializer">The calling serializer.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { string text; if (value is DateTime) { DateTime dateTime = (DateTime)value; if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal || (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal) dateTime = dateTime.ToUniversalTime(); text = dateTime.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture); } #if !NET20 else if (value is DateTimeOffset) { DateTimeOffset dateTimeOffset = (DateTimeOffset)value; if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal || (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal) dateTimeOffset = dateTimeOffset.ToUniversalTime(); text = dateTimeOffset.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture); } #endif else { throw new JsonSerializationException("Unexpected value when converting date. Expected DateTime or DateTimeOffset, got {0}.".FormatWith(CultureInfo.InvariantCulture, ReflectionUtils.GetObjectType(value))); } writer.WriteValue(text); }
/// <summary> /// Writes the JSON representation of the object. /// </summary> /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param> /// <param name="value">The value.</param> /// <param name="serializer">The calling serializer.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { long ticks; if (value is DateTime) { DateTime dateTime = (DateTime)value; DateTime utcDateTime = dateTime.ToUniversalTime(); ticks = JsonConvert.ConvertDateTimeToJavaScriptTicks(utcDateTime); } #if !PocketPC && !NET20 else if (value is DateTimeOffset) { DateTimeOffset dateTimeOffset = (DateTimeOffset)value; DateTimeOffset utcDateTimeOffset = dateTimeOffset.ToUniversalTime(); ticks = JsonConvert.ConvertDateTimeToJavaScriptTicks(utcDateTimeOffset.UtcDateTime); } #endif else { throw new JsonSerializationException("Expected date object value."); } writer.WriteStartConstructor("Date"); writer.WriteValue(ticks); writer.WriteEndConstructor(); }
/// <summary> /// Reads the JSON representation of the object. /// </summary> /// <param name="reader">The <see cref="JsonReader"/> to read from.</param> /// <param name="objectType">Type of the object.</param> /// <param name="existingValue">The existing value of object being read.</param> /// <param name="serializer">The calling serializer.</param> /// <returns>The object value.</returns> public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { DataTable dt = existingValue as DataTable; if (dt == null) { // handle typed datasets dt = (objectType == typeof(DataTable)) ? new DataTable() : (DataTable)Activator.CreateInstance(objectType); } if (reader.TokenType == JsonToken.PropertyName) { dt.TableName = (string)reader.Value; CheckedRead(reader); } if (reader.TokenType != JsonToken.StartArray) throw JsonSerializationException.Create(reader, "Unexpected JSON token when reading DataTable. Expected StartArray, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType)); CheckedRead(reader); while (reader.TokenType != JsonToken.EndArray) { CreateRow(reader, dt); CheckedRead(reader); } return dt; }
/// <summary> /// Reads the JSON representation of the object. /// </summary> /// <param name="reader">The <see cref="JsonReader"/> to read from.</param> /// <param name="objectType">Type of the object.</param> /// <param name="existingValue">The existing value of object being read.</param> /// <param name="serializer">The calling serializer.</param> /// <returns>The object value.</returns> public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { DataTable dt = existingValue as DataTable; if (dt == null) { // handle typed datasets dt = (objectType == typeof(DataTable)) ? new DataTable() : (DataTable)Activator.CreateInstance(objectType); } if (reader.TokenType == JsonToken.PropertyName) { dt.TableName = (string)reader.Value; reader.Read(); } if (reader.TokenType == JsonToken.StartArray) reader.Read(); while (reader.TokenType != JsonToken.EndArray) { CreateRow(reader, dt); reader.Read(); } return dt; }
/// <summary> /// Writes the JSON representation of the object. /// </summary> /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param> /// <param name="value">The value.</param> /// <param name="serializer">The calling serializer.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { EnsureReflectionObject(value.GetType()); DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver; string keyName = (string)_reflectionObject.GetValue(value, KeyPropertyName); object keyValue = _reflectionObject.GetValue(value, ValuePropertyName); Type keyValueType = (keyValue != null) ? keyValue.GetType() : null; writer.WriteStartObject(); writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyPropertyName) : KeyPropertyName); writer.WriteValue(keyName); writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(TypePropertyName) : TypePropertyName); writer.WriteValue((keyValueType != null) ? keyValueType.FullName : null); writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValuePropertyName) : ValuePropertyName); if (keyValueType != null) { string valueJson; if (JsonSerializerInternalWriter.TryConvertToString(keyValue, keyValueType, out valueJson)) writer.WriteValue(valueJson); else writer.WriteValue(keyValue); } else { writer.WriteNull(); } writer.WriteEndObject(); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { NameContainer nameContainer = new NameContainer(); nameContainer.Value = (string)reader.Value; return nameContainer; }
public void EntitiesTest() { Purchase purchase = new Purchase() { Id = 1 }; purchase.PurchaseLine.Add(new PurchaseLine() { Id = 1, Purchase = purchase }); purchase.PurchaseLine.Add(new PurchaseLine() { Id = 2, Purchase = purchase }); StringWriter sw = new StringWriter(); JsonSerializer serializer = new JsonSerializer(); serializer.ReferenceLoopHandling = ReferenceLoopHandling.Ignore; using (JsonWriter jw = new JsonTextWriter(sw)) { jw.Formatting = Formatting.Indented; serializer.Serialize(jw, purchase); } string json = sw.ToString(); Assert.AreEqual(@"{ ""Id"": 1, ""PurchaseLine"": [ { ""Id"": 1, ""PurchaseReference"": { ""EntityKey"": null, ""RelationshipName"": ""EntityDataModel.PurchasePurchaseLine"", ""SourceRoleName"": ""PurchaseLine"", ""TargetRoleName"": ""Purchase"", ""RelationshipSet"": null, ""IsLoaded"": false }, ""EntityState"": 1, ""EntityKey"": null }, { ""Id"": 2, ""PurchaseReference"": { ""EntityKey"": null, ""RelationshipName"": ""EntityDataModel.PurchasePurchaseLine"", ""SourceRoleName"": ""PurchaseLine"", ""TargetRoleName"": ""Purchase"", ""RelationshipSet"": null, ""IsLoaded"": false }, ""EntityState"": 1, ""EntityKey"": null } ], ""EntityState"": 1, ""EntityKey"": null }", json); Purchase newPurchase = JsonConvert.DeserializeObject<Purchase>(json); Assert.AreEqual(1, newPurchase.Id); Assert.AreEqual(2, newPurchase.PurchaseLine.Count); Assert.AreEqual(1, newPurchase.PurchaseLine.ElementAt(0).Id); Assert.AreEqual(2, newPurchase.PurchaseLine.ElementAt(1).Id); }
/// <summary> /// Reads the JSON representation of the object. /// </summary> /// <param name="reader">The <see cref="JsonReader"/> to read from.</param> /// <param name="objectType">Type of the object.</param> /// <param name="existingValue">The existing property value of the JSON that is being converted.</param> /// <param name="serializer">The calling serializer.</param> /// <returns>The object value.</returns> public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { if (reader.TokenType == JsonToken.Null) { return null; } else { if (reader.TokenType == JsonToken.String) { try { Version v = new Version((string)reader.Value); return v; } catch (Exception ex) { throw JsonSerializationException.Create(reader, "Error parsing version string: {0}".FormatWith(CultureInfo.InvariantCulture, reader.Value), ex); } } else { throw JsonSerializationException.Create(reader, "Unexpected token or value when parsing version. Token: {0}, Value: {1}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType, reader.Value)); } } }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { reader.Read(); Debug.Assert(reader.TokenType == JsonToken.PropertyName); Debug.Assert((string)reader.Value == "coordinates"); if (objectType == typeof(Coordinate)) { return ReadJsonCoordinate(reader); } if (typeof(IEnumerable<Coordinate>).IsAssignableFrom(objectType)) { return ReadJsonCoordinates(reader); } if (typeof(List<Coordinate[]>).IsAssignableFrom(objectType)) { return ReadJsonCoordinatesEnumerable(reader); } if (typeof(List<List<Coordinate[]>>).IsAssignableFrom(objectType)) { return ReadJsonCoordinatesEnumerable2(reader); } throw new Exception(); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { writer.WritePropertyName("coordinates"); List<List<Coordinate[]>> coordinatesss = value as List<List<Coordinate[]>>; if (coordinatesss != null) { WriteJsonCoordinatesEnumerable2(writer, coordinatesss, serializer); return; } List<Coordinate[]> coordinatess = value as List<Coordinate[]>; if (coordinatess != null) { WriteJsonCoordinatesEnumerable(writer, coordinatess, serializer); return; } IEnumerable<Coordinate> coordinates = value as IEnumerable<Coordinate>; if (coordinates != null) { WriteJsonCoordinates(writer, coordinates, serializer); return; } Coordinate coordinate = value as Coordinate; if (coordinate != null) { WriteJsonCoordinate(writer, coordinate, serializer); return; } }
/// <summary> /// Writes the JSON representation of the object. /// </summary> /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param> /// <param name="value">The value.</param> /// <param name="serializer">The calling serializer.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { DataTable table = (DataTable)value; DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver; writer.WriteStartArray(); foreach (DataRow row in table.Rows) { writer.WriteStartObject(); foreach (DataColumn column in row.Table.Columns) { object columnValue = row[column]; if (serializer.NullValueHandling == NullValueHandling.Ignore && (columnValue == null || columnValue == DBNull.Value)) { continue; } writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(column.ColumnName) : column.ColumnName); serializer.Serialize(writer, columnValue); } writer.WriteEndObject(); } writer.WriteEndArray(); }
/// <summary> /// Writes the JSON representation of the object. /// </summary> /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param> /// <param name="value">The value.</param> /// <param name="serializer">The calling serializer.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { if (value == null) { writer.WriteNull(); return; } Enum e = (Enum)value; string enumName = e.ToString("G"); if (char.IsNumber(enumName[0]) || enumName[0] == '-') { writer.WriteValue(value); } else { BidirectionalDictionary<string, string> map = GetEnumNameMap(e.GetType()); string resolvedEnumName; map.TryGetByFirst(enumName, out resolvedEnumName); resolvedEnumName = resolvedEnumName ?? enumName; if (CamelCaseText) { string[] names = resolvedEnumName.Split(',').Select(item => StringUtils.ToCamelCase(item.Trim())).ToArray(); resolvedEnumName = string.Join(", ", names); } writer.WriteValue(resolvedEnumName); } }
// Token: 0x06000685 RID: 1669 // RVA: 0x0003758C File Offset: 0x0003578C public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { if (reader.TokenType == JsonToken.Null) { if (!ReflectionUtils.IsNullable(objectType)) { throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Cannot convert null value to {0}.", CultureInfo.InvariantCulture, objectType)); } return null; } else { if (reader.TokenType != JsonToken.StartConstructor || !string.Equals(reader.Value.ToString(), "Date", StringComparison.Ordinal)) { throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Unexpected token or value when parsing date. Token: {0}, Value: {1}", CultureInfo.InvariantCulture, reader.TokenType, reader.Value)); } reader.Read(); if (reader.TokenType != JsonToken.Integer) { throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Unexpected token parsing date. Expected Integer, got {0}.", CultureInfo.InvariantCulture, reader.TokenType)); } long javaScriptTicks = (long)reader.Value; DateTime dateTime = DateTimeUtils.ConvertJavaScriptTicksToDateTime(javaScriptTicks); reader.Read(); if (reader.TokenType != JsonToken.EndConstructor) { throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Unexpected token parsing date. Expected EndConstructor, got {0}.", CultureInfo.InvariantCulture, reader.TokenType)); } return dateTime; } }
/// <summary> /// Writes the JSON representation of the object. /// </summary> /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param> /// <param name="value">The value.</param> /// <param name="serializer">The calling serializer.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { if (value == null) { writer.WriteNull(); return; } Enum e = (Enum)value; string enumName = e.ToString("G"); if (char.IsNumber(enumName[0]) || enumName[0] == '-') { // enum value has no name so write number writer.WriteValue(value); } else { Type enumType = e.GetType(); string finalName = EnumUtils.ToEnumName(enumType, enumName, CamelCaseText); writer.WriteValue(finalName); } }
private static void WriteJsonCoordinatesEnumerable2(JsonWriter writer, List<List<Coordinate[]>> coordinates, JsonSerializer serializer) { writer.WriteStartArray(); foreach (List<Coordinate[]> coordinate in coordinates) WriteJsonCoordinatesEnumerable(writer, coordinate, serializer); writer.WriteEndArray(); }
/// <summary> /// Writes the JSON representation of the object. /// </summary> /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param> /// <param name="value">The value.</param> /// <param name="serializer">The calling serializer.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { //long ticks; /*if (value is DateTime) { DateTime dateTime = (DateTime)value; DateTime utcDateTime = dateTime.ToUniversalTime(); ticks = JsonConvert.ConvertDateTimeToJavaScriptTicks(utcDateTime); } else if (value is DateTimeOffset) { DateTimeOffset dateTimeOffset = (DateTimeOffset)value; DateTimeOffset utcDateTimeOffset = dateTimeOffset.ToUniversalTime(); ticks = JsonConvert.ConvertDateTimeToJavaScriptTicks(utcDateTimeOffset.UtcDateTime); } else { throw new Exception("Expected date object value."); }*/ //writer.WriteStartConstructor("Date"); //writer.WriteValue(ticks); //writer.WriteEndConstructor(); if (value is DateTime) { DateTime dateTime = (DateTime)value; DateTime vLocValue = DateTime.SpecifyKind(dateTime, DateTimeKind.Utc); writer.WriteValue(vLocValue); } else { throw new Exception("Expected date object value."); } }
public void Date() { var serializer = new JsonSerializer(); DateTime EPOCH = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); Action<DateTime, string> CheckDate = (date, json) => { var result = serializer.Deserialize<DateTime>(json); var diff = date.Subtract(result); Assert.IsTrue(diff.TotalSeconds < 1, string.Format("Dates do not match: <{0}> != <{1}>, difference: {2}, json: <{3}>", date, result, diff.TotalSeconds, json)); }; Action<DateTime> TestDate = (source) => { CheckDate(source, string.Format("new Date({0})", (long)(source - EPOCH).TotalMilliseconds)); CheckDate(source, string.Format("new Date(\"{0}\")", source.ToString("MMMM d, yyyy HH:mm:ss zzz"))); CheckDate(source, string.Format("new Date({0}, {1}, {2}, {3}, {4}, {5}, {6})", source.Year, source.Month, source.Day, source.Hour, source.Minute, source.Second, source.Millisecond)); }; TestDate(new DateTime(1970, 1, 2, 0, 0, 0, DateTimeKind.Utc)); TestDate(new DateTime(1970, 1, 2, 4, 0, 0, DateTimeKind.Utc)); TestDate(new DateTime(1970, 1, 2, 14, 0, 0, DateTimeKind.Utc)); TestDate(DateTime.Now); TestDate(DateTime.UtcNow); CheckDate(new DateTime(1970, 1, 2, 4, 1, 2), "new Date(1970, 1, 2, 14, 0, 0)"); CheckDate(new DateTime(1970, 1, 2, 4, 1, 0), "new Date(1970, 1, 2, 14, 0)"); CheckDate(new DateTime(1970, 1, 2, 4, 0, 0), "new Date(1970, 1, 2, 14)"); CheckDate(new DateTime(1970, 1, 2, 0, 0, 0), "new Date(1970, 1, 2)"); }
private static void WriteJsonCoordinates(JsonWriter writer, IEnumerable<Coordinate> coordinates, JsonSerializer serializer) { writer.WriteStartArray(); foreach (Coordinate coordinate in coordinates) WriteJsonCoordinate(writer, coordinate, serializer); writer.WriteEndArray(); }
/// <summary> /// Writes the JSON representation of the object. /// </summary> /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param> /// <param name="value">The value.</param> /// <param name="serializer">The calling serializer.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { IEntityKeyMember entityKeyMember = DynamicWrapper.CreateWrapper<IEntityKeyMember>(value); Type keyType = (entityKeyMember.Value != null) ? entityKeyMember.Value.GetType() : null; writer.WriteStartObject(); writer.WritePropertyName("Key"); writer.WriteValue(entityKeyMember.Key); writer.WritePropertyName("Type"); writer.WriteValue((keyType != null) ? keyType.FullName : null); writer.WritePropertyName("Value"); if (keyType != null) { string valueJson; if (JsonSerializerInternalWriter.TryConvertToString(entityKeyMember.Value, keyType, out valueJson)) writer.WriteValue(valueJson); else writer.WriteValue(entityKeyMember.Value); } else { writer.WriteNull(); } writer.WriteEndObject(); }
/// <summary> /// Reads the JSON representation of the object. /// </summary> /// <param name="reader">The <see cref="JsonReader"/> to read from.</param> /// <param name="objectType">Type of the object.</param> /// <param name="existingValue">The existing value of object being read.</param> /// <param name="serializer">The calling serializer.</param> /// <returns>The object value.</returns> public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { // handle typed datasets DataSet ds = (objectType == typeof(DataSet)) ? new DataSet() : (DataSet)Activator.CreateInstance(objectType); DataTableConverter converter = new DataTableConverter(); reader.Read(); while (reader.TokenType == JsonToken.PropertyName) { DataTable dt = ds.Tables[(string)reader.Value]; bool exists = (dt != null); dt = (DataTable)converter.ReadJson(reader, typeof(DataTable), dt, serializer); if (!exists) ds.Tables.Add(dt); reader.Read(); } return ds; }
public MapReduceIndex(Directory directory, int id, IndexDefinition indexDefinition, AbstractViewGenerator viewGenerator, WorkContext context) : base(directory, id, indexDefinition, viewGenerator, context) { jsonSerializer = JsonExtensions.CreateDefaultJsonSerializer(); jsonSerializer.Converters = MapReduceConverters; }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { // NOTE: THIS DOESN'T SUPPORT READING OF DynamicJsonObject !!! var o = RavenJToken.Load(reader); return (o.Type == JTokenType.Null || o.Type == JTokenType.Undefined) ? null : o; }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { User user = new User(); user.UserName = (string)reader.Value; return user; }
public DatabaseSettingsSectionViewModel() { serializer = ApplicationModel.Current.Server.Value.DocumentStore.Conventions.CreateSerializer(); serializer.Formatting = Formatting.Indented; SectionName = "Database Settings"; }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { var converter = GetConverter(value.GetType()); var text = converter.ConvertToInvariantString(value); writer.WriteValue(text); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { if(value == null) { writer.WriteNull(); return; } if ((value as UniquenessType?).HasValue) writer.WriteValue(enumToStrings[typeof(UniquenessType?)](value)); else if ((value as TraversalStrategy?).HasValue) writer.WriteValue(enumToStrings[typeof(TraversalStrategy?)](value)); else if ((value as TraversalOrder?).HasValue) writer.WriteValue(enumToStrings[typeof(TraversalOrder?)](value)); else if ((value as TraversalItemOrder?).HasValue) writer.WriteValue(enumToStrings[typeof(TraversalItemOrder?)](value)); else if ((value as EdgeDirection?).HasValue) writer.WriteValue(enumToStrings[typeof(EdgeDirection?)](value)); else throw new InvalidOperationException($"cant find binding to serialize type {value.GetType()}, this is client bug"); }
public void testJsonDeserializingAnalyticServiceStatus() { String source = "{" + "\"service_status\":\"online\"," + "\"api_version\":\"2.0\"," + "\"service_version\":\"1.0.2.63\"," + "\"supported_encoding\":\"UTF-8\"," + "\"supported_compression\":\"gzip\"," + "\"supported_languages\":[" + "\"English\"," + "\"French\"" + "]" + "}"; ISerializer serializer = new JsonSerializer(); Status status = serializer.Deserialize<Status>(source); Assert.AreEqual("online", status.Service); Assert.AreEqual("2.0", status.ApiVersion); Assert.AreEqual("1.0.2.63", status.ServiceVersion); Assert.AreEqual("UTF-8", status.SupportedEncoding); Assert.AreEqual("gzip", status.SupportedCompression); Assert.AreEqual(2, status.SupportedLanguages.Count); Assert.AreEqual("English", status.SupportedLanguages[0]); Assert.AreEqual("French", status.SupportedLanguages[1]); }
public JsonSerializerProxy(JsonSerializerWriter serializerWriter) { ValidationUtils.ArgumentNotNull(serializerWriter, "serializerWriter"); _serializerWriter = serializerWriter; _serializer = serializerWriter._serializer; }
/// <summary> /// Writes the JSON representation of the object. /// </summary> /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param> /// <param name="value">The value.</param> /// <param name="serializer">The calling serializer.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { if (value == null) { writer.WriteNull(); return; } Enum e = (Enum)value; string enumName = e.ToString("G"); if (char.IsNumber(enumName[0]) || enumName[0] == '-') { writer.WriteValue(value); } else { BidirectionalDictionary<string, string> map = GetEnumNameMap(e.GetType()); string resolvedEnumName; map.TryGetByFirst(enumName, out resolvedEnumName); resolvedEnumName = resolvedEnumName ?? enumName; if (CamelCaseText) resolvedEnumName = StringUtils.ToCamelCase(resolvedEnumName); writer.WriteValue(resolvedEnumName); } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { throw new NotImplementedException(); }
public T As <T>() => JsonSerializer.DeserializeFromString <T>(this.json);
public static JsonArrayObjects Parse(string json) { return(JsonSerializer.DeserializeFromString <JsonArrayObjects>(json)); }
internal static VirtualMachineScaleSetUpdateNetworkConfiguration DeserializeVirtualMachineScaleSetUpdateNetworkConfiguration(JsonElement element) { Optional <string> name = default; Optional <ResourceIdentifier> id = default; Optional <bool> primary = default; Optional <bool> enableAcceleratedNetworking = default; Optional <bool> enableFpga = default; Optional <WritableSubResource> networkSecurityGroup = default; Optional <VirtualMachineScaleSetNetworkConfigurationDnsSettings> dnsSettings = default; Optional <IList <VirtualMachineScaleSetUpdateIPConfiguration> > ipConfigurations = default; Optional <bool> enableIPForwarding = default; Optional <DeleteOptions> deleteOption = default; foreach (var property in element.EnumerateObject()) { if (property.NameEquals("name")) { name = property.Value.GetString(); continue; } if (property.NameEquals("id")) { if (property.Value.ValueKind == JsonValueKind.Null) { property.ThrowNonNullablePropertyIsNull(); continue; } id = new ResourceIdentifier(property.Value.GetString()); continue; } if (property.NameEquals("properties")) { if (property.Value.ValueKind == JsonValueKind.Null) { property.ThrowNonNullablePropertyIsNull(); continue; } foreach (var property0 in property.Value.EnumerateObject()) { if (property0.NameEquals("primary")) { if (property0.Value.ValueKind == JsonValueKind.Null) { property0.ThrowNonNullablePropertyIsNull(); continue; } primary = property0.Value.GetBoolean(); continue; } if (property0.NameEquals("enableAcceleratedNetworking")) { if (property0.Value.ValueKind == JsonValueKind.Null) { property0.ThrowNonNullablePropertyIsNull(); continue; } enableAcceleratedNetworking = property0.Value.GetBoolean(); continue; } if (property0.NameEquals("enableFpga")) { if (property0.Value.ValueKind == JsonValueKind.Null) { property0.ThrowNonNullablePropertyIsNull(); continue; } enableFpga = property0.Value.GetBoolean(); continue; } if (property0.NameEquals("networkSecurityGroup")) { if (property0.Value.ValueKind == JsonValueKind.Null) { property0.ThrowNonNullablePropertyIsNull(); continue; } networkSecurityGroup = JsonSerializer.Deserialize <WritableSubResource>(property0.Value.ToString()); continue; } if (property0.NameEquals("dnsSettings")) { if (property0.Value.ValueKind == JsonValueKind.Null) { property0.ThrowNonNullablePropertyIsNull(); continue; } dnsSettings = VirtualMachineScaleSetNetworkConfigurationDnsSettings.DeserializeVirtualMachineScaleSetNetworkConfigurationDnsSettings(property0.Value); continue; } if (property0.NameEquals("ipConfigurations")) { if (property0.Value.ValueKind == JsonValueKind.Null) { property0.ThrowNonNullablePropertyIsNull(); continue; } List <VirtualMachineScaleSetUpdateIPConfiguration> array = new List <VirtualMachineScaleSetUpdateIPConfiguration>(); foreach (var item in property0.Value.EnumerateArray()) { array.Add(VirtualMachineScaleSetUpdateIPConfiguration.DeserializeVirtualMachineScaleSetUpdateIPConfiguration(item)); } ipConfigurations = array; continue; } if (property0.NameEquals("enableIPForwarding")) { if (property0.Value.ValueKind == JsonValueKind.Null) { property0.ThrowNonNullablePropertyIsNull(); continue; } enableIPForwarding = property0.Value.GetBoolean(); continue; } if (property0.NameEquals("deleteOption")) { if (property0.Value.ValueKind == JsonValueKind.Null) { property0.ThrowNonNullablePropertyIsNull(); continue; } deleteOption = new DeleteOptions(property0.Value.GetString()); continue; } } continue; } } return(new VirtualMachineScaleSetUpdateNetworkConfiguration(id.Value, name.Value, Optional.ToNullable(primary), Optional.ToNullable(enableAcceleratedNetworking), Optional.ToNullable(enableFpga), networkSecurityGroup, dnsSettings.Value, Optional.ToList(ipConfigurations), Optional.ToNullable(enableIPForwarding), Optional.ToNullable(deleteOption))); }
void IUtf8JsonSerializable.Write(Utf8JsonWriter writer) { writer.WriteStartObject(); if (Optional.IsDefined(Name)) { writer.WritePropertyName("name"); writer.WriteStringValue(Name); } if (Optional.IsDefined(Id)) { writer.WritePropertyName("id"); writer.WriteStringValue(Id); } writer.WritePropertyName("properties"); writer.WriteStartObject(); if (Optional.IsDefined(Primary)) { writer.WritePropertyName("primary"); writer.WriteBooleanValue(Primary.Value); } if (Optional.IsDefined(EnableAcceleratedNetworking)) { writer.WritePropertyName("enableAcceleratedNetworking"); writer.WriteBooleanValue(EnableAcceleratedNetworking.Value); } if (Optional.IsDefined(EnableFpga)) { writer.WritePropertyName("enableFpga"); writer.WriteBooleanValue(EnableFpga.Value); } if (Optional.IsDefined(NetworkSecurityGroup)) { writer.WritePropertyName("networkSecurityGroup"); JsonSerializer.Serialize(writer, NetworkSecurityGroup); } if (Optional.IsDefined(DnsSettings)) { writer.WritePropertyName("dnsSettings"); writer.WriteObjectValue(DnsSettings); } if (Optional.IsCollectionDefined(IPConfigurations)) { writer.WritePropertyName("ipConfigurations"); writer.WriteStartArray(); foreach (var item in IPConfigurations) { writer.WriteObjectValue(item); } writer.WriteEndArray(); } if (Optional.IsDefined(EnableIPForwarding)) { writer.WritePropertyName("enableIPForwarding"); writer.WriteBooleanValue(EnableIPForwarding.Value); } if (Optional.IsDefined(DeleteOption)) { writer.WritePropertyName("deleteOption"); writer.WriteStringValue(DeleteOption.Value.ToString()); } writer.WriteEndObject(); writer.WriteEndObject(); }
public override void WriteJson(JsonWriter writer, Version value, JsonSerializer serializer) { writer.WriteValue(value.ToString()); }
public override Version ReadJson(JsonReader reader, Type objectType, Version existingValue, bool hasExistingValue, JsonSerializer serializer) { string s = (string)reader.Value; return(new Version(s)); }
internal static StaticSiteUserProvidedFunctionApp DeserializeStaticSiteUserProvidedFunctionApp(JsonElement element) { Optional <string> kind = default; ResourceIdentifier id = default; string name = default; ResourceType type = default; SystemData systemData = default; Optional <string> functionAppResourceId = default; Optional <string> functionAppRegion = default; Optional <DateTimeOffset> createdOn = default; foreach (var property in element.EnumerateObject()) { if (property.NameEquals("kind")) { kind = property.Value.GetString(); continue; } if (property.NameEquals("id")) { id = new ResourceIdentifier(property.Value.GetString()); continue; } if (property.NameEquals("name")) { name = property.Value.GetString(); continue; } if (property.NameEquals("type")) { type = property.Value.GetString(); continue; } if (property.NameEquals("systemData")) { systemData = JsonSerializer.Deserialize <SystemData>(property.Value.ToString()); continue; } if (property.NameEquals("properties")) { if (property.Value.ValueKind == JsonValueKind.Null) { property.ThrowNonNullablePropertyIsNull(); continue; } foreach (var property0 in property.Value.EnumerateObject()) { if (property0.NameEquals("functionAppResourceId")) { functionAppResourceId = property0.Value.GetString(); continue; } if (property0.NameEquals("functionAppRegion")) { functionAppRegion = property0.Value.GetString(); continue; } if (property0.NameEquals("createdOn")) { if (property0.Value.ValueKind == JsonValueKind.Null) { property0.ThrowNonNullablePropertyIsNull(); continue; } createdOn = property0.Value.GetDateTimeOffset("O"); continue; } } continue; } } return(new StaticSiteUserProvidedFunctionApp(id, name, type, systemData, kind.Value, functionAppResourceId.Value, functionAppRegion.Value, Optional.ToNullable(createdOn))); }
/// <summary> /// Reads JSON /// </summary> /// <param name="reader">JSON reader</param> /// <param name="objectType">Object type</param> /// <param name="existingValue">Existing value</param> /// <param name="hasExistingValue">Has existing value</param> /// <param name="serializer">JSON serializer</param> /// <returns>Language</returns> public override ELanguage ReadJson(JsonReader reader, Type objectType, ELanguage existingValue, bool hasExistingValue, JsonSerializer serializer) { ELanguage ret = existingValue; if (reader.Value is string value) { switch (value) { case "english_gb": ret = ELanguage.EnglishGB; break; case "english": ret = ELanguage.EnglishUS; break; default: if (!Enum.TryParse(Naming.UpperFirstCharacter(value), out ret)) { ret = ELanguage.Invalid; } break; } } return(ret); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { if (reader.TokenType == JsonToken.Null) { return(null); } try { int defaultCount = 0; var contract = (JsonObjectContract)serializer.ContractResolver.ResolveContract(objectType); if (existingValue == null) { existingValue = contract.DefaultCreator(); } while (reader.Read()) { switch (reader.TokenType) { case JsonToken.Comment: break; case JsonToken.PropertyName: { var name = reader.Value.ToString(); var property = contract.Properties.GetClosestMatchProperty(name); if (!reader.Read()) { throw new JsonSerializationException(string.Format("Missing value at path: {0}", reader.Path)); } if (property == null) { property = contract.Properties.Where(p => p.AttributeProvider.GetAttributes(true).OfType <JsonAnyPropertyNameAttribute>().Any()).Single(); defaultCount++; if (defaultCount > 1) { throw new JsonSerializationException(string.Format("Too many properties with unknown names for type {0} at path {1}", objectType, reader.Path)); } } var value = serializer.Deserialize(reader, property.PropertyType); property.ValueProvider.SetValue(existingValue, value); } break; case JsonToken.EndObject: return(existingValue); default: throw new JsonSerializationException(string.Format("Unknown token {0} at path: {1} ", reader.TokenType, reader.Path)); } } throw new JsonSerializationException(string.Format("Unclosed object at path: {0}", reader.Path)); } catch (Exception ex) { if (ex is JsonException) { throw; } // Wrap any exceptions encountered in a JsonSerializationException throw new JsonSerializationException(string.Format("Error deserializing type {0} at path {1}", objectType, reader.Path), ex); } }
/// <summary> /// Reads the JSON representation of the object. /// </summary> /// <param name="reader">The <see cref="JsonReader"/> to read from.</param> /// <param name="objectType">Type of the object.</param> /// <param name="existingValue">The existing value of object being read.</param> /// <param name="serializer">The calling serializer.</param> /// <returns>The object value.</returns> public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { DataSet ds = new DataSet(); DataTableConverter converter = new DataTableConverter(); reader.Read(); while (reader.TokenType == JsonToken.PropertyName) { DataTable dt = (DataTable)converter.ReadJson(reader, typeof(DataTable), null, serializer); ds.Tables.Add(dt); reader.Read(); } return(ds); }
/// <summary> /// Writes JSON /// </summary> /// <param name="writer">JSON writer</param> /// <param name="value">Language value</param> /// <param name="serializer">JSON serializer</param> public override void WriteJson(JsonWriter writer, ELanguage value, JsonSerializer serializer) => writer.WriteValue(Naming.GetLanguageString(value));
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { var underlyingObjectType = objectType.GetNotNullableTypeOrOriginal(); var objectTypeIsNullable = (underlyingObjectType != objectType); if (!underlyingObjectType.IsEnum) { throw new JsonSerializationException(string.Format( "Cannot convert value to non-enum {0}", objectType)); } if (reader.TokenType == JsonToken.Null) { if (!objectTypeIsNullable) { throw new JsonSerializationException(string.Format( "Cannot convert null value to {0}", objectType)); } return(null); } if (reader.TokenType != JsonToken.String) { throw new JsonSerializationException(string.Format( "Cannot convert {0} token to {1}", reader.TokenType.ToString(), objectType)); } try { var jsonValue = reader.Value.ToString(); foreach (var enumValueDeclaration in underlyingObjectType.GetFields(BindingFlags.Public | BindingFlags.Static)) { var enumValueAttribute = (JsonEnumValueAttribute)enumValueDeclaration .GetCustomAttributes(typeof(JsonEnumValueAttribute), false) .FirstOrDefault(); if (enumValueAttribute == null) { continue; } if (enumValueAttribute.Value == jsonValue) { return(enumValueDeclaration.GetValue(null)); } } } catch (Exception e) { throw new JsonSerializationException(string.Format( "Error parsing value \"{0}\" as {1}", reader.Value, objectType), e); } if (IsStrict) { throw new JsonSerializationException(string.Format( "Error parsing value \"{0}\" as {1}", reader.Value, objectType)); } return(existingValue); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { var properties = new PropertiesBag(); while (reader.Read()) { if (reader.TokenType != JsonToken.PropertyName) { break; } var key = reader.Value.ToString(); reader.Read(); var value = reader.Value; if (value is DateTime dateTime) { properties.Set(key, dateTime.ToInstant()); } else { properties.Set(key, value); } } return properties; }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { writer.WriteValue(value?.ToString()); }
private void GrdResult_CellBeginEdit(object sender, DataGridViewCellCancelEventArgs e) { var cell = grdResult.Rows[e.RowIndex].Cells[e.ColumnIndex]; cell.Value = JsonSerializer.Serialize(cell.Tag as BsonValue); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { User user = (User)value; writer.WriteValue(user.UserName); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) => reader.Value == null ? null : ConvertFromString((string)reader.Value, objectType);
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { throw new NotImplementedException(); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { User user = new User(); user.UserName = (string)reader.Value; return(user); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { var constructor = objectType.GetConstructor(Type.EmptyTypes); var instance = constructor.Invoke(null); if (reader.ValueType.IsSimple()) { return(reader.Value); } var properties = objectType.GetProperties().ToDictionary(x => this.Simplify(x.Name), x => x); foreach (var jProperty in JObject.Load(reader).Properties()) { var property = this.FindBestMatch(properties, jProperty.Name, 3); if (property == null) { continue; } if (property.PropertyType.IsArray && !(jProperty.Value is JArray)) { this.ParseDictionaryAsListByType( property.PropertyType.GetElementType(), jProperty, serializer, property, instance ); } else { property.SetValue(instance, jProperty.Value.ToObject(property.PropertyType, serializer)); } } return(instance); }
/// <summary> /// Dies Methode hält die Kommuniktion mit dem Client aufrecht, um den Synchronisierungsfortschritt /// pro Foto in den Ausgabefluss zu schreiben /// </summary> /// <param name="stream">Der Stream mit dem Client</param> /// <param name="content">Der Inhalt des Streams. Wird nicht verwendet, ist aber für den Aufruf erfordern</param> /// <param name="context">Der Context der Verbindung. Wird nicht verwendet, ist aber für den Aufruf erfordern</param> /// <remarks>Es ist nicht sichergestellt, dass die Verbindung offen bleibt. Außerdem ist unklar wie die Browser auf den /// Flush reaagieren, so dass das Parsen der einzelnen Fortschirttinformatioen <see cref="SynchProgress"/> nicht klar ist</remarks> public void OnStreamAvailable(Stream stream, HttpContent content, TransportContext context) { try { var serializer = new JsonSerializer(); var memberId = GetMemberId(); bool streamIsOpen = true; foreach (var currentStep in _connector.RefreshFolderContent()) { try { NotificationHub.PushNotification(new Notification() { Data = currentStep, Type = NotificationType.PhotoSynch, Date = DateTime.Now, MemberId = memberId, PhotoName = currentStep.Photo == null ? string.Empty : currentStep.Photo.Name, PhotoTitle = currentStep.Photo == null ? string.Empty : currentStep.Photo.Title }); if (currentStep.Photo != null) { SavePhotosToDatabase(currentStep.Photo); } if (!streamIsOpen) continue; using (var writer = new StreamWriter(stream)) { if (currentStep.Photo != null) { dynamic currentPhoto = new { currentStep.Photo.Id, currentStep.Photo.Title, currentStep.Photo.Name, currentStep.Photo.OriginalName, currentStep.Photo.MemberId, currentStep.Photo.IsPrivate, DirectLinks = currentStep.Photo.DirectLinks.Where(l => l.Size <= 400).ToList(), currentStep.Photo.Color }; dynamic progress = new { currentStep.TotalFileCount, currentStep.Index, Photo = currentPhoto }; var returnValue = new Result<object>() { Data = progress }; serializer.Serialize(writer, returnValue); } else { var returnValue = new Result<SynchProgress> { Data = currentStep }; serializer.Serialize(writer, returnValue); } stream.Flush(); } } catch (HttpException ex) { // Die Verbindung zum Client wurde unterbrochen, die Synchronisierung läuft jedoch weiter if (ex.ErrorCode == -2147023667) { streamIsOpen = false; } } } var notification = new Notification() { Type = NotificationType.PhotoSynch, MemberId = memberId, UserAlias = "fotosteam" }; DataRepository.Add(notification); } catch (Exception ex) { Log.Error(ex); var error = new Result<SynchProgress> { Data = new SynchProgress() }; error.Status.Code = Controller.StatusCode.Failure; error.Status.Message = ResultMessages.UnhandledException; try { using (var writer = new StreamWriter(stream)) { var serializer = new JsonSerializer(); serializer.Serialize(writer, error); } } catch (Exception ex1) { //Da können wir jetzt auch nicht mehr machen. Log.Error(ex1); } } finally { // Close output stream as we are done stream.Close(); } }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { if (reader.Value is string vs) { return new List <string> { vs } } ; else if (reader.Value is int vi) { return new List <string> { vi.ToString() } } ; else if (reader.Value is long vl) { return new List <string> { vl.ToString() } } ; else { var list = serializer.Deserialize <List <string> >(reader); return(list.Count < 1 ? null : list); } }
private void ParseDictionaryAsListByType(Type elementType, JProperty jp, JsonSerializer serializer, PropertyInfo prop, object instance) => this.InvokePrivateGeneric <object>(nameof(ParseDictionaryAsList), elementType, jp, serializer, prop, instance);
/// <summary> /// Writes the value of the parameters to json format /// </summary> /// <param name="writer">Json writer</param> /// <param name="value">Value to be converted to json format</param> /// <param name="serializer">Json serializer</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { serializer.Serialize(writer, value); }
public async Task <CustomerBasket> GetBasketAsync(string basketId) { var data = await _database.StringGetAsync(basketId); return(data.IsNullOrEmpty ? null : JsonSerializer.Deserialize <CustomerBasket>(data)); }
public sealed override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { bool existingIsNull = existingValue == null; if (!(existingIsNull || existingValue is T)) { throw new JsonSerializationException($"Converter cannot read JSON with the specified existing value. {typeof(T)} is required."); } return(ReadJson(reader, objectType, existingIsNull ? default : (T)existingValue, !existingIsNull, serializer)); }
/// <summary> /// Read the json format and return the correct object type/value for it /// </summary> /// <param name="reader">Json reader</param> /// <param name="objectType">Type of property being set</param> /// <param name="existingValue">The current value of the property being set</param> /// <param name="serializer">Json serializer</param> /// <returns>The object value of the converted json value</returns> public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { switch (reader.TokenType) { case JsonToken.StartObject: try { JObject jObject = JObject.Load(reader); return(jObject.ToObject <Dictionary <string, object> >()); } catch (Exception) { throw new Exception("Request parameters can only be an associative array, list or null."); } case JsonToken.StartArray: return(JArray.Load(reader).ToObject <object[]>(serializer)); case JsonToken.Null: return(null); } throw new Exception("Request parameters can only be an associative array, list or null."); }
public abstract void WriteJson(JsonWriter writer, T value, JsonSerializer serializer);
public abstract T ReadJson(JsonReader reader, Type objectType, T existingValue, bool hasExistingValue, JsonSerializer serializer);