protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(value != null); Debug.Assert(writer != null); if (_properties.Count == 0) { writer.WriteString(value.ToString()); } else { writer.WriteStartObject(); foreach (PropertyDescriptor property in _properties) { object propertyValue = property.GetValue(value); if (!JsonNull.LogicallyEquals(propertyValue)) { writer.WriteMember(property.Name); context.Export(propertyValue, writer); } } writer.WriteEndObject(); } }
/// <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(); }
protected override void FormatOther(object o, JsonWriter writer) { if (writer == null) throw new ArgumentNullException("writer"); if (JNull.LogicallyEquals(o)) { FormatNull(o, writer); return; } writer.WriteStartObject(); if (_properties == null) _properties = TypeDescriptor.GetProperties(o); foreach (PropertyDescriptor property in _properties) { // TODO: Allow someone to indicate via an attribute (e.g. JsonIgnore) that a property should be excluded. object value = property.GetValue(o); if (!JNull.LogicallyEquals(value)) { writer.WriteMember(property.Name); writer.WriteValue(value); } } writer.WriteEndObject(); }
private static void ExportDataSet(ExportContext context, DataSet dataSet, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(dataSet != null); Debug.Assert(writer != null); writer.WriteStartObject(); foreach (DataTable table in dataSet.Tables) { writer.WriteMember(table.TableName); // // If there is an exporter (perhaps an override) for the // DataTable in effect then use it. Otherwise our // DataTableExporter. // IExporter tableExporter = context.FindExporter(table.GetType()); if (tableExporter != null) tableExporter.Export(context, table, writer); else DataTableExporter.ExportTable(context, table, writer); } writer.WriteEndObject(); }
/// <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) { DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver; IEntityKeyMember entityKeyMember = DynamicWrapper.CreateWrapper<IEntityKeyMember>(value); Type keyType = (entityKeyMember.Value != null) ? entityKeyMember.Value.GetType() : null; writer.WriteStartObject(); writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyPropertyName) : KeyPropertyName); writer.WriteValue(entityKeyMember.Key); writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(TypePropertyName) : TypePropertyName); writer.WriteValue((keyType != null) ? keyType.FullName : null); writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValuePropertyName) : ValuePropertyName); 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> /// 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 void WritesEmptyObject() { var sw = new StringWriter(); var writer = new JsonWriter(sw); writer.WriteStartObject(); writer.WriteEnd(); Assert.AreEqual("{}", sw.ToString()); }
private void WriteJsonValue(JsonWriter writer, IJsonValue value) { switch (value.ValueType) { case JsonValueType.Array: { JsonArray a = value.GetArray(); writer.WriteStartArray(); for (int i = 0; i < a.Count; i++) { WriteJsonValue(writer, a[i]); } writer.WriteEndArray(); } break; case JsonValueType.Boolean: { writer.WriteValue(value.GetBoolean()); } break; case JsonValueType.Null: { writer.WriteNull(); } break; case JsonValueType.Number: { // JsonValue doesn't support integers // serialize whole numbers without a decimal point double d = value.GetNumber(); bool isInteger = (d % 1 == 0); if (isInteger && d <= long.MaxValue && d >= long.MinValue) writer.WriteValue(Convert.ToInt64(d)); else writer.WriteValue(d); } break; case JsonValueType.Object: { JsonObject o = value.GetObject(); writer.WriteStartObject(); foreach (KeyValuePair<string, IJsonValue> v in o) { writer.WritePropertyName(v.Key); WriteJsonValue(writer, v.Value); } writer.WriteEndObject(); } break; case JsonValueType.String: { writer.WriteValue(value.GetString()); } break; default: throw new ArgumentOutOfRangeException("ValueType"); } }
public void WritesSinglePropertyObject() { var sw = new StringWriter(); var writer = new JsonWriter(sw); writer.WriteStartObject(); writer.WriteName("A").WriteValue(1); writer.WriteEnd(); Assert.AreEqual("{\"A\": 1}", sw.ToString()); }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { if (context == null) throw new ArgumentNullException("context"); if (writer == null) throw new ArgumentNullException("writer"); writer.WriteStartObject(); ExportMembers(context, (ExpandoObject) value, writer); writer.WriteEndObject(); }
private void WriteJson(JsonWriter writer, Regex regex) { writer.WriteStartObject(); writer.WritePropertyName("Pattern"); writer.WriteValue(regex.ToString()); writer.WritePropertyName("Options"); writer.WriteValue(regex.Options); writer.WriteEndObject(); }
// Token: 0x0600019E RID: 414 // RVA: 0x0002BC3C File Offset: 0x00029E3C public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { ReflectionObject reflectionObject = KeyValuePairConverter.ReflectionObjectPerType.Get(value.GetType()); DefaultContractResolver defaultContractResolver = serializer.ContractResolver as DefaultContractResolver; writer.WriteStartObject(); writer.WritePropertyName((defaultContractResolver != null) ? defaultContractResolver.GetResolvedPropertyName("Key") : "Key"); serializer.Serialize(writer, reflectionObject.GetValue(value, "Key"), reflectionObject.GetType("Key")); writer.WritePropertyName((defaultContractResolver != null) ? defaultContractResolver.GetResolvedPropertyName("Value") : "Value"); serializer.Serialize(writer, reflectionObject.GetValue(value, "Value"), reflectionObject.GetType("Value")); writer.WriteEndObject(); }
/// <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> public override void WriteJson(JsonWriter writer, object value) { XmlNode node = value as XmlNode; if (node == null) throw new ArgumentException("Value must be an XmlNode", "value"); writer.WriteStartObject(); SerializeNode(writer, node, true); writer.WriteEndObject(); }
internal static void FormatTable(DataTable table, JsonWriter writer) { Debug.Assert(table != null); Debug.Assert(writer != null); writer.WriteStartObject(); writer.WriteMember("rows"); writer.WriteValue(table.Rows); writer.WriteEndObject(); }
private static void FormatRowView(DataRowView rowView, JsonWriter writer) { writer.WriteStartObject(); foreach (DataColumn column in rowView.DataView.Table.Columns) { writer.WriteMember(column.ColumnName); writer.WriteValue(rowView[column.Ordinal]); } writer.WriteEndObject(); }
private static void FormatDataSet(DataSet dataSet, JsonWriter writer) { writer.WriteStartObject(); foreach (DataTable table in dataSet.Tables) { writer.WriteMember(table.TableName); DataTableFormatter.FormatTable(table, writer); } writer.WriteEndObject(); }
public void UnnamedObjectProperty() { var sw = new StringWriter(); var writer = new JsonWriter(sw); writer.WriteStartObject(); try { writer.WriteValue(1); Assert.Fail("Did not throw the expected exception"); } catch (NotSupportedException ex) { Assert.AreEqual("Object properties must have a name written first", ex.Message); } }
protected override void ExportValue(ExportContext context, object value, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(value != null); Debug.Assert(writer != null); if (_properties.Count == 0) { writer.WriteString(value.ToString()); } else { ObjectReferenceTracker tracker = null; try { writer.WriteStartObject(); foreach (PropertyDescriptor property in _properties) { object propertyValue = property.GetValue(value); if (!JsonNull.LogicallyEquals(propertyValue)) { writer.WriteMember(property.Name); if (tracker == null) { // // We are about to enter a deeper scope so // start tracking the current object being // exported. This will help to detect // recursive references that may occur // through this exporter deeper in the tree. // tracker = TrackObject(context, value); } context.Export(propertyValue, writer); } } writer.WriteEndObject(); } finally { if (tracker != null) tracker.Pop(value); } } }
/// <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) { Type t = value.GetType(); PropertyInfo keyProperty = t.GetProperty("Key"); PropertyInfo valueProperty = t.GetProperty("Value"); writer.WriteStartObject(); writer.WritePropertyName("Key"); serializer.Serialize(writer, ReflectionUtils.GetMemberValue(keyProperty, value)); writer.WritePropertyName("Value"); serializer.Serialize(writer, ReflectionUtils.GetMemberValue(valueProperty, value)); writer.WriteEndObject(); }
/// <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) { ReflectionObject reflectionObject = ReflectionObjectPerType.Get(value.GetType()); DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver; writer.WriteStartObject(); writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyName) : KeyName); serializer.Serialize(writer, reflectionObject.GetValue(value, KeyName), reflectionObject.GetType(KeyName)); writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValueName) : ValueName); serializer.Serialize(writer, reflectionObject.GetValue(value, ValueName), reflectionObject.GetType(ValueName)); writer.WriteEndObject(); }
private void WriteJsonValue(JsonWriter writer, IJsonValue value) { switch (value.ValueType) { case JsonValueType.Array: { JsonArray a = value.GetArray(); writer.WriteStartArray(); for (int i = 0; i < a.Count; i++) { WriteJsonValue(writer, a[i]); } writer.WriteEndArray(); } break; case JsonValueType.Boolean: { writer.WriteValue(value.GetBoolean()); } break; case JsonValueType.Null: { writer.WriteNull(); } break; case JsonValueType.Number: { writer.WriteValue(value.GetNumber()); } break; case JsonValueType.Object: { JsonObject o = value.GetObject(); writer.WriteStartObject(); foreach (KeyValuePair<string, IJsonValue> v in o) { writer.WritePropertyName(v.Key); WriteJsonValue(writer, v.Value); } writer.WriteEndObject(); } break; case JsonValueType.String: { writer.WriteValue(value.GetString()); } break; default: throw new ArgumentOutOfRangeException("ValueType"); } }
protected override void ExportValue(object value, JsonWriter writer) { writer.WriteStartObject(); IDictionary dictionary = (IDictionary) value; foreach (DictionaryEntry entry in dictionary) { writer.WriteMember(entry.Key.ToString()); writer.WriteValue(entry.Value); } writer.WriteEndObject(); }
internal static void FormatDataRow(DataRow row, JsonWriter writer) { Debug.Assert(row != null); Debug.Assert(writer != null); writer.WriteStartObject(); foreach (DataColumn column in row.Table.Columns) { writer.WriteMember(column.ColumnName); writer.WriteValue(row[column]); } writer.WriteEndObject(); }
/// <summary> /// Writes the JSON representation of the object. /// </summary> /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param> /// <param name="serializer">The calling serializer.</param> /// <param name="value">The value.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { IXmlNode node = WrapXml(value); XmlNamespaceManager manager = new XmlNamespaceManager(new NameTable()); PushParentNamespaces(node, manager); if (!OmitRootObject) writer.WriteStartObject(); SerializeNode(writer, node, manager, !OmitRootObject); if (!OmitRootObject) writer.WriteEndObject(); }
private void SerializePrimitive(JsonWriter writer, object value, JsonPrimitiveContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty) { if (contract.UnderlyingType == typeof(byte[])) { bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Objects, contract, member, containerContract, containerProperty); if (includeTypeDetails) { writer.WriteStartObject(); WriteTypeProperty(writer, contract.CreatedType); writer.WritePropertyName(JsonTypeReflector.ValuePropertyName); writer.WriteValue(value); writer.WriteEndObject(); return; } } writer.WriteValue(value); }
private static void ExportDataSet(DataSet dataSet, JsonWriter writer) { Debug.Assert(dataSet != null); Debug.Assert(writer != null); writer.WriteStartObject(); foreach (DataTable table in dataSet.Tables) { writer.WriteMember(table.TableName); DataTableExporter.ExportTable(table, writer); } writer.WriteEndObject(); }
internal static void ExportRecord(ExportContext context, ICustomTypeDescriptor record, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(record != null); Debug.Assert(writer != null); writer.WriteStartObject(); foreach (PropertyDescriptor property in record.GetProperties()) { writer.WriteMember(property.Name); context.Export(property.GetValue(record), writer); } writer.WriteEndObject(); }
/// <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) { Type t = value.GetType(); PropertyInfo keyProperty = t.GetProperty(KeyName); PropertyInfo valueProperty = t.GetProperty(ValueName); DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver; writer.WriteStartObject(); writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyName) : KeyName); serializer.Serialize(writer, ReflectionUtils.GetMemberValue(keyProperty, value)); writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValueName) : ValueName); serializer.Serialize(writer, ReflectionUtils.GetMemberValue(valueProperty, value)); writer.WriteEndObject(); }
internal static void ExportRow(ExportContext context, DataRow row, JsonWriter writer) { Debug.Assert(context != null); Debug.Assert(row != null); Debug.Assert(writer != null); writer.WriteStartObject(); foreach (DataColumn column in row.Table.Columns) { writer.WriteMember(column.ColumnName); context.Export(row[column], writer); } writer.WriteEndObject(); }
public static void Serialize(Madingley.Common.Configuration configuration, TextWriter textWriter) { Action <Newtonsoft.Json.JsonWriter, Madingley.Common.FunctionalGroupDefinition> JsonAddPropertyFunctionalGroupDefinition = (JsonWriter, value) => { JsonWriter.WriteStartObject(); Common.Writer.PropertyKeyValuePairs(JsonWriter, "Definitions", value.Definitions, Common.Writer.PropertyString); Common.Writer.PropertyKeyValuePairs(JsonWriter, "Properties", value.Properties, Common.Writer.PropertyDouble); JsonWriter.WriteEndObject(); }; Action <Newtonsoft.Json.JsonWriter, string, Madingley.Common.FunctionalGroupDefinitions> JsonAddPropertyFunctionalGroupDefinitions = (JsonWriter, name, value) => { JsonWriter.WritePropertyName(name); JsonWriter.WriteStartObject(); Common.Writer.PropertyArray(JsonWriter, "Data", value.Data, JsonAddPropertyFunctionalGroupDefinition); Common.Writer.PropertyInlineArray(JsonWriter, "Definitions", value.Definitions, Common.Writer.WriteString); Common.Writer.PropertyInlineArray(JsonWriter, "Properties", value.Properties, Common.Writer.WriteString); JsonWriter.WriteEndObject(); }; Action <Newtonsoft.Json.JsonWriter, string, Madingley.Common.ScenarioParameter> JsonAddPropertyScenarioParameter = (JsonWriter, name, value) => { JsonWriter.WritePropertyName(name); JsonWriter.WriteStartObject(); Common.Writer.PropertyString(JsonWriter, "ParamString", value.ParamString); Common.Writer.PropertyDouble(JsonWriter, "ParamDouble1", value.ParamDouble1); Common.Writer.PropertyDouble(JsonWriter, "ParamDouble2", value.ParamDouble2); JsonWriter.WriteEndObject(); }; Action <Newtonsoft.Json.JsonWriter, Madingley.Common.ScenarioParameters> JsonAddScenarioParameter = (JsonWriter, value) => { JsonWriter.WriteStartObject(); Common.Writer.PropertyString(JsonWriter, "Label", value.Label); Common.Writer.PropertyInt(JsonWriter, "SimulationNumber", value.SimulationNumber); Common.Writer.PropertyKeyValuePairs(JsonWriter, "Parameters", value.Parameters, JsonAddPropertyScenarioParameter); JsonWriter.WriteEndObject(); }; Action <Newtonsoft.Json.JsonWriter, string, Madingley.Common.EcologicalParameters> JsonAddEcologicalParameters = (JsonWriter, name, ecologicalParameters) => { JsonWriter.WritePropertyName(name); JsonWriter.WriteStartObject(); Common.Writer.PropertyKeyValuePairs(JsonWriter, "Parameters", ecologicalParameters.Parameters, Common.Writer.PropertyDouble); Common.Writer.PropertyInlineArray(JsonWriter, "TimeUnits", ecologicalParameters.TimeUnits, Common.Writer.WriteString); JsonWriter.WriteEndObject(); }; using (var writer = new Newtonsoft.Json.JsonTextWriter(textWriter)) { writer.Formatting = Newtonsoft.Json.Formatting.Indented; writer.WriteStartObject(); Common.Writer.PropertyString(writer, "GlobalModelTimeStepUnit", configuration.GlobalModelTimeStepUnit); Common.Writer.PropertyInt(writer, "NumTimeSteps", configuration.NumTimeSteps); Common.Writer.PropertyInt(writer, "BurninTimeSteps", configuration.BurninTimeSteps); Common.Writer.PropertyInt(writer, "ImpactTimeSteps", configuration.ImpactTimeSteps); Common.Writer.PropertyInt(writer, "RecoveryTimeSteps", configuration.RecoveryTimeSteps); Common.Writer.PropertyBoolean(writer, "RunCellsInParallel", configuration.RunCellsInParallel); Common.Writer.PropertyBoolean(writer, "RunSimulationsInParallel", configuration.RunSimulationsInParallel); Common.Writer.PropertyString(writer, "RunRealm", configuration.RunRealm); Common.Writer.PropertyBoolean(writer, "DrawRandomly", configuration.DrawRandomly); Common.Writer.PropertyDouble(writer, "ExtinctionThreshold", configuration.ExtinctionThreshold); Common.Writer.PropertyInt(writer, "MaxNumberOfCohorts", configuration.MaxNumberOfCohorts); Common.Writer.PropertyBoolean(writer, "DispersalOnly", configuration.DispersalOnly); Common.Writer.PropertyString(writer, "DispersalOnlyType", configuration.DispersalOnlyType); Common.Writer.PropertyDouble(writer, "PlanktonDispersalThreshold", configuration.PlanktonDispersalThreshold); JsonAddPropertyFunctionalGroupDefinitions(writer, "CohortFunctionalGroupDefinitions", configuration.CohortFunctionalGroupDefinitions); JsonAddPropertyFunctionalGroupDefinitions(writer, "StockFunctionalGroupDefinitions", configuration.StockFunctionalGroupDefinitions); Common.Writer.PropertyInlineArray(writer, "ImpactCellIndices", configuration.ImpactCellIndices, Common.Writer.WriteInt); Common.Writer.PropertyBoolean(writer, "ImpactAll", configuration.ImpactAll); Common.Writer.PropertyArray(writer, "ScenarioParameters", configuration.ScenarioParameters, JsonAddScenarioParameter); Common.Writer.PropertyInt(writer, "ScenarioIndex", configuration.ScenarioIndex); Common.Writer.PropertyInt(writer, "Simulation", configuration.Simulation); JsonAddEcologicalParameters(writer, "EcologicalParameters", configuration.EcologicalParameters); Common.Writer.PropertyInlineArray(writer, "FileNames", configuration.FileNames, Common.Writer.WriteString); writer.WriteEndObject(); } }
public static void WriteTo(this ICursor source, JsonWriter writer, bool stripNullValues = true) { if (source == null || source.IsNull) { writer.WriteNull(); } else { switch (source.Schema.DataType) { case DataType.Class: if (source.Schema.Id == (int)BuiltInSchema.Variable) { var content = source.GoTo((int)VariableLayout.Data, true); if (!content.IsNull && content.Schema.DataType != DataType.String && content.Schema.DataType != DataType.Boolean && (content.Schema.DataType == DataType.List || content.Schema.DataType == DataType.MultiChoice || EditablePrimitive.IsSupportedType(content.Schema.DataType) ) ) { writer.WriteStartObject(); writer.WritePropertyName("@schema"); writer.WriteValue(source.Schema.Name); writer.WritePropertyName("DataSchema"); writer.WriteValue(content.Schema.Name); writer.WritePropertyName("Data"); content.WriteTo(writer, stripNullValues); writer.WriteEndObject(); } else { content.WriteTo(writer, stripNullValues); } } else { writer.WriteStartObject(); writer.WritePropertyName("@schema"); writer.WriteValue(source.Schema.Name); foreach (var f in source.Schema.Fields) { var field = source.GoTo(f, false); if (!stripNullValues || !field.IsNull) { writer.WritePropertyName(f.Name); field.WriteTo(writer, stripNullValues); } } writer.WriteEndObject(); } break; case DataType.MultiChoice: case DataType.List: { writer.WriteStartArray(); for (int i = 0; i < source.Count; ++i) { var field = source.GoTo(i, false); if (!stripNullValues || !field.IsNull) { field.WriteTo(writer, stripNullValues); } } writer.WriteEndArray(); } break; default: { EditablePrimitive.PrimitiveType typeHelper; if (EditablePrimitive.TryGetPrimitiveTypeHelper(source.Schema, out typeHelper)) { typeHelper.JsonWrite(writer, source.Get()); } else { throw new Exception(string.Format("Unable to convert data type '{0}' to JSON string.", source.Schema.DataType)); } } break; } } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { switch (value) { case PsbNull _: writer.WriteNull(); break; case PsbBool b: writer.WriteValue(b.Value); break; case PsbNumber num: switch (num.NumberType) { case PsbNumberType.Int: writer.WriteValue(num.IntValue); break; case PsbNumberType.Float: if (num.FloatValue.IsFinite() && !UseHexNumber) { writer.WriteValue(num.FloatValue); } else { writer.WriteValue($"{Consts.NumberStringPrefix}{num.IntValue:X8}f"); } //writer.WriteRawValue(num.FloatValue.ToString("R")); break; case PsbNumberType.Double: if (num.DoubleValue.IsFinite() && !UseHexNumber) { writer.WriteValue(num.DoubleValue); } else { writer.WriteValue($"{Consts.NumberStringPrefix}{num.LongValue:X16}d"); } break; default: writer.WriteValue(num.LongValue); break; } break; case PsbString str: writer.WriteValue(str.Value); break; case PsbResource res: //writer.WriteValue(Convert.ToBase64String(res.Data, Base64FormattingOptions.None)); writer.WriteValue($"{Consts.ResourceIdentifier}{res.Index}"); break; case PsbArray array: writer.WriteValue(array.Value); break; case PsbList collection: if (ArrayCollapse) { writer.WriteStartArray(); if (collection.Count > 0 && !(collection[0] is IPsbCollection)) { writer.Formatting = Formatting.None; } foreach (var obj in collection) { WriteJson(writer, obj, serializer); } writer.WriteEndArray(); writer.Formatting = Formatting.Indented; } else { writer.WriteStartArray(); foreach (var obj in collection) { WriteJson(writer, obj, serializer); } writer.WriteEndArray(); } break; case PsbDictionary dictionary: writer.WriteStartObject(); foreach (var obj in dictionary) { writer.WritePropertyName(obj.Key); WriteJson(writer, obj.Value, serializer); } writer.WriteEndObject(); break; default: break; } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { var ws = (WorkspaceModel)value; bool isCustomNode = value is CustomNodeWorkspaceModel; writer.WriteStartObject(); writer.WritePropertyName("Uuid"); if (isCustomNode) { writer.WriteValue((ws as CustomNodeWorkspaceModel).CustomNodeId.ToString()); } else { writer.WriteValue(ws.Guid.ToString()); } // TODO: revisit IsCustomNode during DYN/DYF convergence writer.WritePropertyName("IsCustomNode"); writer.WriteValue(value is CustomNodeWorkspaceModel ? true : false); if (isCustomNode) { writer.WritePropertyName("Category"); writer.WriteValue(((CustomNodeWorkspaceModel)value).Category); } // Description writer.WritePropertyName("Description"); if (isCustomNode) { writer.WriteValue(((CustomNodeWorkspaceModel)ws).Description); } else { writer.WriteValue(ws.Description); } writer.WritePropertyName("Name"); writer.WriteValue(ws.Name); //element resolver writer.WritePropertyName("ElementResolver"); serializer.Serialize(writer, ws.ElementResolver); //inputs writer.WritePropertyName("Inputs"); //find nodes which are inputs and get their inputData if its not null. var inputNodeDatas = ws.Nodes.Where((node) => node.IsSetAsInput == true && node.InputData != null) .Select(inputNode => inputNode.InputData).ToList(); serializer.Serialize(writer, inputNodeDatas); //outputs writer.WritePropertyName("Outputs"); //find nodes which are outputs and get their outputData if its not null. var outputNodeDatas = ws.Nodes.Where((node) => node.IsSetAsOutput == true && node.OutputData != null) .Select(outputNode => outputNode.OutputData).ToList(); serializer.Serialize(writer, outputNodeDatas); //nodes writer.WritePropertyName("Nodes"); serializer.Serialize(writer, ws.Nodes); //connectors writer.WritePropertyName("Connectors"); serializer.Serialize(writer, ws.Connectors); // Dependencies writer.WritePropertyName("Dependencies"); writer.WriteStartArray(); var functions = ws.Nodes.Where(n => n is Function); if (functions.Any()) { var deps = functions.Cast <Function>().Select(f => f.Definition.FunctionId).Distinct(); foreach (var d in deps) { writer.WriteValue(d); } } writer.WriteEndArray(); if (engine != null) { // Bindings writer.WritePropertyName(Configurations.BindingsTag); writer.WriteStartArray(); // Selecting all nodes that are either a DSFunction, // a DSVarArgFunction or a CodeBlockNodeModel into a list. var nodeGuids = ws.Nodes.Where( n => n is DSFunction || n is DSVarArgFunction || n is CodeBlockNodeModel || n is Function) .Select(n => n.GUID); var nodeTraceDataList = engine.LiveRunnerRuntimeCore.RuntimeData.GetTraceDataForNodes(nodeGuids, this.engine.LiveRunnerRuntimeCore.DSExecutable); // serialize given node-data-list pairs into an Json. if (nodeTraceDataList.Any()) { foreach (var pair in nodeTraceDataList) { writer.WriteStartObject(); writer.WritePropertyName(Configurations.NodeIdAttribName); // Set the node ID attribute for this element. var nodeGuid = pair.Key.ToString(); writer.WriteValue(nodeGuid); writer.WritePropertyName(Configurations.BingdingTag); // D4R binding writer.WriteStartObject(); foreach (var data in pair.Value) { writer.WritePropertyName(data.ID); writer.WriteValue(data.Data); } writer.WriteEndObject(); writer.WriteEndObject(); } } writer.WriteEndArray(); writer.WriteEndObject(); } }
/// <summary> /// Writes the opening tag and the header for the document. /// </summary> /// <param name="mobileDoc"></param> public void EnterMobileDoc(MobileDoc mobileDoc) { _jsonWriter.WriteStartObject(); _jsonWriter.WritePropertyName("version"); _jsonWriter.WriteValue(mobileDoc.Version); }
public override void WriteJson(JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer) { var message = value as Message; writer.WriteStartObject(); writer.WritePropertyName("Topic"); writer.WriteValue(message.Topic); foreach (var name in message.Fields) { var bin = message[name]; var typeRecord = TypeIdentity.Instance[bin.GetInnerType()]; if (typeRecord == null) { continue; } if (typeRecord.CloneMethod == CloneBehaviour.Null) { continue; } string extraType = ""; if (!NativeJsonTypes.Contains(bin.GetInnerType())) { extraType = "<" + typeRecord.Alias + ">"; } writer.WritePropertyName(name + extraType); if (bin.Count != 1) { writer.WriteStartArray(); } foreach (object o in bin) { if (o is Stream) { var sr = new StreamReader((Stream)o); serializer.Serialize(writer, sr.ReadToEnd()); } else { serializer.Serialize(writer, o, bin.GetInnerType()); } } if (bin.Count != 1) { writer.WriteEndArray(); } } writer.WritePropertyName("Stamp"); serializer.Serialize(writer, message.TimeStamp, typeof(Time)); JObject.FromObject(message.TimeStamp, serializer); writer.WriteEndObject(); }
private void SerializeNode(JsonWriter writer, XmlNode node, bool writePropertyName) { switch (node.NodeType) { case XmlNodeType.Document: case XmlNodeType.DocumentFragment: SerializeGroupedNodes(writer, node); break; case XmlNodeType.Element: if (writePropertyName) { writer.WritePropertyName(node.Name); } if (ValueAttributes(node.Attributes).Count() == 0 && node.ChildNodes.Count == 1 && node.ChildNodes[0].NodeType == XmlNodeType.Text) { // write elements with a single text child as a name value pair writer.WriteValue(node.ChildNodes[0].Value); } else if (node.ChildNodes.Count == 0 && CollectionUtils.IsNullOrEmpty(node.Attributes)) { // empty element writer.WriteNull(); } else if (node.ChildNodes.OfType <XmlElement>().Where(x => x.Name.StartsWith("-")).Count() > 1) { XmlElement constructorValueElement = node.ChildNodes.OfType <XmlElement>().Where(x => x.Name.StartsWith("-")).First(); string constructorName = constructorValueElement.Name.Substring(1); writer.WriteStartConstructor(constructorName); for (int i = 0; i < node.ChildNodes.Count; i++) { SerializeNode(writer, node.ChildNodes[i], false); } writer.WriteEndConstructor(); } else { writer.WriteStartObject(); for (int i = 0; i < node.Attributes.Count; i++) { SerializeNode(writer, node.Attributes[i], true); } SerializeGroupedNodes(writer, node); writer.WriteEndObject(); } break; case XmlNodeType.Comment: if (writePropertyName) { writer.WriteComment(node.Value); } break; case XmlNodeType.Attribute: case XmlNodeType.Text: case XmlNodeType.CDATA: case XmlNodeType.ProcessingInstruction: case XmlNodeType.Whitespace: case XmlNodeType.SignificantWhitespace: if (node.Prefix == "xmlns" && node.Value == JsonNamespaceUri) { break; } else if (node.NamespaceURI == JsonNamespaceUri) { break; } if (writePropertyName) { writer.WritePropertyName(GetPropertyName(node)); } writer.WriteValue(node.Value); break; case XmlNodeType.XmlDeclaration: XmlDeclaration declaration = (XmlDeclaration)node; writer.WritePropertyName(GetPropertyName(node)); writer.WriteStartObject(); if (!string.IsNullOrEmpty(declaration.Version)) { writer.WritePropertyName("@version"); writer.WriteValue(declaration.Version); } if (!string.IsNullOrEmpty(declaration.Encoding)) { writer.WritePropertyName("@encoding"); writer.WriteValue(declaration.Encoding); } if (!string.IsNullOrEmpty(declaration.Standalone)) { writer.WritePropertyName("@standalone"); writer.WriteValue(declaration.Standalone); } writer.WriteEndObject(); break; default: throw new JsonSerializationException("Unexpected XmlNodeType when serializing nodes: " + node.NodeType); } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { var dictionary = (IDictionary)value; if (dictionary == null) { writer.WriteNull(); return; } var settings = serializer.GetConnectionSettings(); var seenEntries = new Dictionary <string, object>(dictionary.Count); Field fieldName; PropertyName propertyName; IndexName indexName; TypeName typeName; foreach (DictionaryEntry entry in dictionary) { if (entry.Value == null && serializer.NullValueHandling == NullValueHandling.Ignore) { continue; } string key; if (settings == null) { key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture); } else if (AsType(entry.Key, out fieldName)) { key = settings.Inferrer.Field(fieldName); } else if (AsType(entry.Key, out propertyName)) { if (propertyName?.Property != null) { IPropertyMapping mapping; if (settings.PropertyMappings.TryGetValue(propertyName.Property, out mapping) && mapping.Ignore) { continue; } } key = settings.Inferrer.PropertyName(propertyName); } else if (AsType(entry.Key, out indexName)) { key = settings.Inferrer.IndexName(indexName); } else if (AsType(entry.Key, out typeName)) { key = settings.Inferrer.TypeName(typeName); } else { key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture); } if (key != null) { seenEntries[key] = entry.Value; } } writer.WriteStartObject(); foreach (var entry in seenEntries) { writer.WritePropertyName(entry.Key); serializer.Serialize(writer, entry.Value); } writer.WriteEndObject(); }
private void SerializeDictionary(JsonWriter writer, IWrappedDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContract collectionValueContract) { contract.InvokeOnSerializing(values.UnderlyingDictionary, base.Serializer.Context); this.SerializeStack.Add(values.UnderlyingDictionary); writer.WriteStartObject(); bool?isReference = contract.IsReference; if ((!isReference.HasValue ? this.HasFlag(base.Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects) : isReference.Value)) { writer.WritePropertyName("$id"); writer.WriteValue(base.Serializer.ReferenceResolver.GetReference(this, values.UnderlyingDictionary)); } if (this.ShouldWriteType(TypeNameHandling.Objects, contract, member, collectionValueContract)) { this.WriteTypeProperty(writer, values.UnderlyingDictionary.GetType()); } JsonContract jsonContract = base.Serializer.ContractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object)); int top = writer.Top; IDictionaryEnumerator enumerator = values.GetEnumerator(); try { while (enumerator.MoveNext()) { DictionaryEntry current = (DictionaryEntry)enumerator.Current; string propertyName = this.GetPropertyName(current); propertyName = (contract.PropertyNameResolver == null ? propertyName : contract.PropertyNameResolver(propertyName)); try { object value = current.Value; JsonContract contractSafe = this.GetContractSafe(value); if (this.ShouldWriteReference(value, null, contractSafe)) { writer.WritePropertyName(propertyName); this.WriteReference(writer, value); } else if (this.CheckForCircularReference(value, null, contract)) { writer.WritePropertyName(propertyName); this.SerializeValue(writer, value, contractSafe, null, jsonContract); } else { continue; } } catch (Exception exception) { if (!base.IsErrorHandled(values.UnderlyingDictionary, contract, propertyName, exception)) { throw; } else { this.HandleError(writer, top); } } } } finally { IDisposable disposable = enumerator as IDisposable; IDisposable disposable1 = disposable; if (disposable != null) { disposable1.Dispose(); } } writer.WriteEndObject(); this.SerializeStack.RemoveAt(this.SerializeStack.Count - 1); contract.InvokeOnSerialized(values.UnderlyingDictionary, base.Serializer.Context); }
private void WriteRootObjectProperties(JsonWriter jsonWriter) { var att = this._propertyNameResolver.GetElasticPropertyFor(this._type); if (att == null) { return; } if (!att.DateDetection) { jsonWriter.WritePropertyName("date_detection"); jsonWriter.WriteRawValue("false"); } if (att.NumericDetection) { jsonWriter.WritePropertyName("numeric_detection"); jsonWriter.WriteRawValue("true"); } if (!att.IndexAnalyzer.IsNullOrEmpty()) { jsonWriter.WritePropertyName("index_analyzer"); jsonWriter.WriteValue(att.IndexAnalyzer); } if (!att.SearchAnalyzer.IsNullOrEmpty()) { jsonWriter.WritePropertyName("search_analyzer"); jsonWriter.WriteValue(att.SearchAnalyzer); } if (!att.SearchAnalyzer.IsNullOrEmpty()) { jsonWriter.WritePropertyName("search_analyzer"); jsonWriter.WriteValue(att.SearchAnalyzer); } if (!att.ParentType.IsNullOrEmpty()) { jsonWriter.WritePropertyName("_parent"); jsonWriter.WriteStartObject(); { jsonWriter.WritePropertyName("type"); jsonWriter.WriteValue(att.ParentType); } jsonWriter.WriteEndObject(); } if (att.DisableAllField) { jsonWriter.WritePropertyName("_all"); jsonWriter.WriteStartObject(); { jsonWriter.WritePropertyName("enabled"); jsonWriter.WriteValue("false"); } jsonWriter.WriteEndObject(); } if (att.DynamicDateFormats != null && att.DynamicDateFormats.Any()) { jsonWriter.WritePropertyName("dynamic_date_formats"); jsonWriter.WriteStartArray(); foreach (var d in att.DynamicDateFormats) { jsonWriter.WriteValue(d); } jsonWriter.WriteEndArray(); } }
/// <summary> /// Serializes the object to JSON. /// </summary> /// <param name="writer">The <see cref="T: Newtonsoft.Json.JsonWriter" /> to write to.</param> /// <param name="obj">The object to serialize to JSON.</param> internal static void Serialize(JsonWriter writer, ApplicationUpgradeProgressInfo obj) { // Required properties are always serialized, optional properties are serialized when not null. writer.WriteStartObject(); writer.WriteProperty(obj.UpgradeState, "UpgradeState", UpgradeStateConverter.Serialize); writer.WriteProperty(obj.RollingUpgradeMode, "RollingUpgradeMode", UpgradeModeConverter.Serialize); writer.WriteProperty(obj.FailureReason, "FailureReason", FailureReasonConverter.Serialize); if (obj.Name != null) { writer.WriteProperty(obj.Name, "Name", JsonWriterExtensions.WriteStringValue); } if (obj.TypeName != null) { writer.WriteProperty(obj.TypeName, "TypeName", JsonWriterExtensions.WriteStringValue); } if (obj.TargetApplicationTypeVersion != null) { writer.WriteProperty(obj.TargetApplicationTypeVersion, "TargetApplicationTypeVersion", JsonWriterExtensions.WriteStringValue); } if (obj.UpgradeDomains != null) { writer.WriteEnumerableProperty(obj.UpgradeDomains, "UpgradeDomains", UpgradeDomainInfoConverter.Serialize); } if (obj.NextUpgradeDomain != null) { writer.WriteProperty(obj.NextUpgradeDomain, "NextUpgradeDomain", JsonWriterExtensions.WriteStringValue); } if (obj.UpgradeDescription != null) { writer.WriteProperty(obj.UpgradeDescription, "UpgradeDescription", ApplicationUpgradeDescriptionConverter.Serialize); } if (obj.UpgradeDurationInMilliseconds != null) { writer.WriteProperty(obj.UpgradeDurationInMilliseconds, "UpgradeDurationInMilliseconds", JsonWriterExtensions.WriteStringValue); } if (obj.UpgradeDomainDurationInMilliseconds != null) { writer.WriteProperty(obj.UpgradeDomainDurationInMilliseconds, "UpgradeDomainDurationInMilliseconds", JsonWriterExtensions.WriteStringValue); } if (obj.UnhealthyEvaluations != null) { writer.WriteEnumerableProperty(obj.UnhealthyEvaluations, "UnhealthyEvaluations", HealthEvaluationWrapperConverter.Serialize); } if (obj.CurrentUpgradeDomainProgress != null) { writer.WriteProperty(obj.CurrentUpgradeDomainProgress, "CurrentUpgradeDomainProgress", CurrentUpgradeDomainProgressInfoConverter.Serialize); } if (obj.StartTimestampUtc != null) { writer.WriteProperty(obj.StartTimestampUtc, "StartTimestampUtc", JsonWriterExtensions.WriteStringValue); } if (obj.FailureTimestampUtc != null) { writer.WriteProperty(obj.FailureTimestampUtc, "FailureTimestampUtc", JsonWriterExtensions.WriteStringValue); } if (obj.UpgradeDomainProgressAtFailure != null) { writer.WriteProperty(obj.UpgradeDomainProgressAtFailure, "UpgradeDomainProgressAtFailure", FailureUpgradeDomainProgressInfoConverter.Serialize); } if (obj.UpgradeStatusDetails != null) { writer.WriteProperty(obj.UpgradeStatusDetails, "UpgradeStatusDetails", JsonWriterExtensions.WriteStringValue); } writer.WriteEndObject(); }
/// <inheritdoc/> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { // P2 to P1 var testCase = value as TestCase; writer.WriteStartObject(); writer.WritePropertyName("Properties"); writer.WriteStartArray(); // Version Note: In 15.0.0, if some properties in TestCase were not set, they were not serialized. // Starting 15.1.0, test platform sends in default values for properties that were not set. This is not // a breaking change. // TestCase.FullyQualifiedName writer.WriteStartObject(); AddProperty(writer, TestCaseProperties.FullyQualifiedName, serializer); writer.WriteValue(testCase.FullyQualifiedName); writer.WriteEndObject(); // TestCase.ExecutorUri writer.WriteStartObject(); AddProperty(writer, TestCaseProperties.ExecutorUri, serializer); writer.WriteValue(testCase.ExecutorUri.OriginalString); writer.WriteEndObject(); // TestCase.Source writer.WriteStartObject(); AddProperty(writer, TestCaseProperties.Source, serializer); writer.WriteValue(testCase.Source); writer.WriteEndObject(); // TestCase.CodeFilePath writer.WriteStartObject(); AddProperty(writer, TestCaseProperties.CodeFilePath, serializer); writer.WriteValue(testCase.CodeFilePath); writer.WriteEndObject(); // TestCase.DisplayName writer.WriteStartObject(); AddProperty(writer, TestCaseProperties.DisplayName, serializer); writer.WriteValue(testCase.DisplayName); writer.WriteEndObject(); // TestCase.Id writer.WriteStartObject(); AddProperty(writer, TestCaseProperties.Id, serializer); writer.WriteValue(testCase.Id); writer.WriteEndObject(); // TestCase.LineNumber writer.WriteStartObject(); AddProperty(writer, TestCaseProperties.LineNumber, serializer); writer.WriteValue(testCase.LineNumber); writer.WriteEndObject(); foreach (var property in testCase.GetProperties()) { serializer.Serialize(writer, property); } writer.WriteEndArray(); writer.WriteEndObject(); }
private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContract collectionValueContract) { contract.InvokeOnSerializing(values.UnderlyingCollection, Serializer.Context); SerializeStack.Add(values.UnderlyingCollection); bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays); bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Arrays, contract, member, collectionValueContract); if (isReference || includeTypeDetails) { writer.WriteStartObject(); if (isReference) { writer.WritePropertyName(JsonTypeReflector.IdPropertyName); writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, values.UnderlyingCollection)); } if (includeTypeDetails) { WriteTypeProperty(writer, values.UnderlyingCollection.GetType()); } writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName); } JsonContract childValuesContract = Serializer.ContractResolver.ResolveContract(contract.CollectionItemType ?? typeof(object)); writer.WriteStartArray(); int initialDepth = writer.Top; int index = 0; // note that an error in the IEnumerable won't be caught foreach (object value in values) { try { JsonContract valueContract = GetContractSafe(value); if (ShouldWriteReference(value, null, valueContract)) { WriteReference(writer, value); } else { if (CheckForCircularReference(value, null, contract)) { SerializeValue(writer, value, valueContract, null, childValuesContract); } } } catch (Exception ex) { if (IsErrorHandled(values.UnderlyingCollection, contract, index, ex)) { HandleError(writer, initialDepth); } else { throw; } } finally { index++; } } writer.WriteEndArray(); if (isReference || includeTypeDetails) { writer.WriteEndObject(); } SerializeStack.RemoveAt(SerializeStack.Count - 1); contract.InvokeOnSerialized(values.UnderlyingCollection, Serializer.Context); }
public void WriteTo(ProjectionVersion projectionVersion, IEnumerable <KeyValuePair <string, JToken> > extraMetaData, JsonWriter jsonWriter) { jsonWriter.WriteStartObject(); if (projectionVersion.ProjectionId > 0) { jsonWriter.WritePropertyName("$v"); WriteVersion(projectionVersion, jsonWriter); } if (Phase != 0) { jsonWriter.WritePropertyName("$ph"); jsonWriter.WriteValue(Phase); } switch (Mode_) { case Mode.Phase: jsonWriter.WritePropertyName("$cp"); jsonWriter.WriteValue(Completed); break; case Mode.Position: case Mode.EventTypeIndex: jsonWriter.WritePropertyName("$c"); jsonWriter.WriteValue(CommitPosition.GetValueOrDefault()); jsonWriter.WritePropertyName("$p"); jsonWriter.WriteValue(PreparePosition.GetValueOrDefault()); if (Mode_ == Mode.EventTypeIndex) { goto case Mode.MultiStream; } break; case Mode.PreparePosition: jsonWriter.WritePropertyName("$p"); jsonWriter.WriteValue(PreparePosition.GetValueOrDefault()); break; case Mode.Stream: case Mode.MultiStream: jsonWriter.WritePropertyName("$s"); jsonWriter.WriteStartObject(); foreach (var stream in Streams) { jsonWriter.WritePropertyName(stream.Key); jsonWriter.WriteValue(stream.Value); } jsonWriter.WriteEndObject(); break; case Mode.ByStream: jsonWriter.WritePropertyName("$m"); jsonWriter.WriteValue("bs"); jsonWriter.WritePropertyName("$c"); jsonWriter.WriteValue(CommitPosition.GetValueOrDefault()); jsonWriter.WritePropertyName("$s"); jsonWriter.WriteStartArray(); jsonWriter.WriteStartObject(); jsonWriter.WritePropertyName(CatalogStream); jsonWriter.WriteValue(CatalogPosition); jsonWriter.WriteEndObject(); if (!string.IsNullOrEmpty(DataStream)) { jsonWriter.WriteStartObject(); jsonWriter.WritePropertyName(DataStream); jsonWriter.WriteValue(DataPosition); jsonWriter.WriteEndObject(); } jsonWriter.WriteEndArray(); break; } if (extraMetaData != null) { foreach (var pair in extraMetaData) { jsonWriter.WritePropertyName(pair.Key); pair.Value.WriteTo(jsonWriter); } } jsonWriter.WriteEndObject(); }
private void WriteJsonValue(JsonWriter writer, IJsonValue value) { switch (value.ValueType) { case JsonValueType.Array: { JsonArray a = value.GetArray(); writer.WriteStartArray(); for (int i = 0; i < a.Count; i++) { WriteJsonValue(writer, a[i]); } writer.WriteEndArray(); } break; case JsonValueType.Boolean: { writer.WriteValue(value.GetBoolean()); } break; case JsonValueType.Null: { writer.WriteNull(); } break; case JsonValueType.Number: { // JsonValue doesn't support integers // serialize whole numbers without a decimal point double d = value.GetNumber(); bool isInteger = (d % 1 == 0); if (isInteger && d <= long.MaxValue && d >= long.MinValue) { writer.WriteValue(Convert.ToInt64(d)); } else { writer.WriteValue(d); } } break; case JsonValueType.Object: { JsonObject o = value.GetObject(); writer.WriteStartObject(); foreach (KeyValuePair <string, IJsonValue> v in o) { writer.WritePropertyName(v.Key); WriteJsonValue(writer, v.Value); } writer.WriteEndObject(); } break; case JsonValueType.String: { writer.WriteValue(value.GetString()); } break; default: throw new ArgumentOutOfRangeException("ValueType"); } }
private void SerializeNode(JsonWriter writer, IXmlNode node, XmlNamespaceManager manager, bool writePropertyName) { switch (node.NodeType) { case XmlNodeType.Document: case XmlNodeType.DocumentFragment: SerializeGroupedNodes(writer, node, manager, writePropertyName); break; case XmlNodeType.Element: if (IsArray(node) && node.ChildNodes.All((IXmlNode n) => n.LocalName == node.LocalName) && node.ChildNodes.Count > 0) { SerializeGroupedNodes(writer, node, manager, writePropertyName: false); } else { foreach (IXmlNode attribute in node.Attributes) { if (attribute.NamespaceURI == "http://www.w3.org/2000/xmlns/") { string prefix = (!(attribute.LocalName != "xmlns")) ? string.Empty : attribute.LocalName; manager.AddNamespace(prefix, attribute.Value); } } if (writePropertyName) { writer.WritePropertyName(GetPropertyName(node, manager)); } if (ValueAttributes(node.Attributes).Count() == 0 && node.ChildNodes.Count == 1 && node.ChildNodes[0].NodeType == XmlNodeType.Text) { writer.WriteValue(node.ChildNodes[0].Value); } else if (node.ChildNodes.Count == 0 && CollectionUtils.IsNullOrEmpty(node.Attributes)) { writer.WriteNull(); } else { writer.WriteStartObject(); for (int i = 0; i < node.Attributes.Count; i++) { SerializeNode(writer, node.Attributes[i], manager, writePropertyName: true); } SerializeGroupedNodes(writer, node, manager, writePropertyName: true); writer.WriteEndObject(); } } break; case XmlNodeType.Comment: if (writePropertyName) { writer.WriteComment(node.Value); } break; case XmlNodeType.Attribute: case XmlNodeType.Text: case XmlNodeType.CDATA: case XmlNodeType.ProcessingInstruction: case XmlNodeType.Whitespace: case XmlNodeType.SignificantWhitespace: if ((!(node.NamespaceURI == "http://www.w3.org/2000/xmlns/") || !(node.Value == "http://james.newtonking.com/projects/json")) && (!(node.NamespaceURI == "http://james.newtonking.com/projects/json") || !(node.LocalName == "Array"))) { if (writePropertyName) { writer.WritePropertyName(GetPropertyName(node, manager)); } writer.WriteValue(node.Value); } break; case XmlNodeType.XmlDeclaration: { IXmlDeclaration xmlDeclaration = (IXmlDeclaration)node; writer.WritePropertyName(GetPropertyName(node, manager)); writer.WriteStartObject(); if (!string.IsNullOrEmpty(xmlDeclaration.Version)) { writer.WritePropertyName("@version"); writer.WriteValue(xmlDeclaration.Version); } if (!string.IsNullOrEmpty(xmlDeclaration.Encoding)) { writer.WritePropertyName("@encoding"); writer.WriteValue(xmlDeclaration.Encoding); } if (!string.IsNullOrEmpty(xmlDeclaration.Standalone)) { writer.WritePropertyName("@standalone"); writer.WriteValue(xmlDeclaration.Standalone); } writer.WriteEndObject(); break; } default: throw new JsonSerializationException("Unexpected XmlNodeType when serializing nodes: " + node.NodeType); } }
private void WriteStartObject() { _writer.WriteStartObject(); IncreaseDepth(); }
public override void WriteStartObject() { _innerWriter.WriteStartObject(); AfterStart(); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { var tagHelper = (TagHelperDescriptor)value; writer.WriteStartObject(); writer.WritePropertyName(nameof(TagHelperDescriptor.Kind)); writer.WriteValue(tagHelper.Kind); writer.WritePropertyName(nameof(TagHelperDescriptor.Name)); writer.WriteValue(tagHelper.Name); writer.WritePropertyName(nameof(TagHelperDescriptor.AssemblyName)); writer.WriteValue(tagHelper.AssemblyName); if (tagHelper.Documentation != null) { writer.WritePropertyName(nameof(TagHelperDescriptor.Documentation)); writer.WriteValue(tagHelper.Documentation); } if (tagHelper.TagOutputHint != null) { writer.WritePropertyName(nameof(TagHelperDescriptor.TagOutputHint)); writer.WriteValue(tagHelper.TagOutputHint); } writer.WritePropertyName(nameof(TagHelperDescriptor.CaseSensitive)); writer.WriteValue(tagHelper.CaseSensitive); writer.WritePropertyName(nameof(TagHelperDescriptor.TagMatchingRules)); writer.WriteStartArray(); foreach (var ruleDescriptor in tagHelper.TagMatchingRules) { WriteTagMatchingRule(writer, ruleDescriptor, serializer); } writer.WriteEndArray(); if (tagHelper.BoundAttributes != null && tagHelper.BoundAttributes.Count > 0) { writer.WritePropertyName(nameof(TagHelperDescriptor.BoundAttributes)); writer.WriteStartArray(); foreach (var boundAttribute in tagHelper.BoundAttributes) { WriteBoundAttribute(writer, boundAttribute, serializer); } writer.WriteEndArray(); } if (tagHelper.AllowedChildTags != null && tagHelper.AllowedChildTags.Count > 0) { writer.WritePropertyName(nameof(TagHelperDescriptor.AllowedChildTags)); writer.WriteStartArray(); foreach (var allowedChildTag in tagHelper.AllowedChildTags) { WriteAllowedChildTags(writer, allowedChildTag, serializer); } writer.WriteEndArray(); } if (tagHelper.Diagnostics != null && tagHelper.Diagnostics.Count > 0) { writer.WritePropertyName(nameof(TagHelperDescriptor.Diagnostics)); serializer.Serialize(writer, tagHelper.Diagnostics); } writer.WritePropertyName(nameof(TagHelperDescriptor.Metadata)); WriteMetadata(writer, tagHelper.Metadata); writer.WriteEndObject(); }
public override void WriteJson(JsonWriter writer, LeagueGame?value, JsonSerializer serializer) { if (value == null) { return; } var retrievalConfiguration = LgoLeagueGameRetrievalConfiguration.GetCurrentOrDefault(); writer.WriteStartObject(); writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.Id))); serializer.Serialize(writer, value.Id); writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.State))); serializer.Serialize(writer, value.State); if (retrievalConfiguration.IncludeGameTimeInSeconds) { writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.GameTimeInSeconds))); serializer.Serialize(writer, value.GameTimeInSeconds); } if (retrievalConfiguration.IncludeMode) { writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.Mode))); serializer.Serialize(writer, value.Mode); } if (retrievalConfiguration.IncludeTeams) { writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.Teams))); serializer.Serialize(writer, value.Teams); } if (retrievalConfiguration.IncludePlayers) { writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.Players))); serializer.Serialize(writer, value.Players); } if (retrievalConfiguration.IncludeMatchUps) { writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.MatchUps))); serializer.Serialize(writer, value.MatchUps); } if (retrievalConfiguration.IncludeTimers) { writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.Timers))); serializer.Serialize(writer, value.Timers); } if (retrievalConfiguration.IncludeEvents) { writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.Events))); serializer.Serialize(writer, value.Events); } if (retrievalConfiguration.IncludeEventsSinceLastUpdate) { writer.WritePropertyName(JsonSerializationHelper.GetPropertyName(value.GetType(), nameof(value.EventsSinceLastUpdate))); serializer.Serialize(writer, value.EventsSinceLastUpdate); } writer.WriteEndObject(); }
public void Serialize(JsonWriter writer) { writer.WriteStartObject(); if (!string.IsNullOrWhiteSpace(Title)) { writer.WritePropertyName("title"); writer.WriteValue(Title); } if (!string.IsNullOrWhiteSpace(Description)) { writer.WritePropertyName("description"); writer.WriteValue(Description); } writer.WritePropertyName("required"); writer.WriteValue(Required); if (TypeFormat.Type != ParameterType.Unknown) { writer.WritePropertyName("type"); writer.WriteValue(TypeFormat.Type.ToString().ToLower()); if (!string.IsNullOrWhiteSpace(TypeFormat.Format)) { writer.WritePropertyName("format"); writer.WriteValue(TypeFormat.Format); } } writer.WritePropertyName("allowEmptyValue"); writer.WriteValue(AllowEmptyValue); if (TypeFormat.Type == ParameterType.Array && Items != null) { writer.WritePropertyName("items"); Items.Serialize(writer); } if (TypeFormat.Type == ParameterType.Array) { writer.WritePropertyName("collectionFormat"); writer.WriteValue(CollectionFormat); } if (!string.IsNullOrWhiteSpace(Default)) { writer.WritePropertyName("default"); writer.WriteValue(Default); } if (Maximum != decimal.MaxValue) { writer.WritePropertyName("maximum"); writer.WriteValue(Maximum); writer.WritePropertyName("exclusiveMaximum"); writer.WriteValue(ExclusiveMaximum); } if (Minimum != decimal.MinValue) { writer.WritePropertyName("minimum"); writer.WriteValue(Minimum); writer.WritePropertyName("exclusiveMinimum"); writer.WriteValue(ExclusiveMinimum); } if (MaxLength != int.MaxValue) { writer.WritePropertyName("maxLength"); writer.WriteValue(MaxLength); } if (MinLength != int.MinValue) { writer.WritePropertyName("minLength"); writer.WriteValue(MinLength); } if (!string.IsNullOrWhiteSpace(Pattern)) { writer.WritePropertyName("pattern"); writer.WriteValue(Pattern); } if (MaxItems != int.MaxValue) { writer.WritePropertyName("maxItems"); writer.WriteValue(MaxItems); } if (MinItems != int.MinValue) { writer.WritePropertyName("minItems"); writer.WriteValue(MinItems); } writer.WritePropertyName("uniqueItems"); writer.WriteValue(UniqueItems); if (Enum != null && Enum.Any()) { writer.WritePropertyName("enum"); writer.WriteStartArray(); foreach (string e in Enum) { writer.WriteValue(e); } writer.WriteEndArray(); } if (MultipleOf != decimal.MinValue) { writer.WritePropertyName("multipleOf"); writer.WriteValue(MultipleOf); } writer.WriteEndObject(); }
private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContract collectionValueContract) { contract.InvokeOnSerializing(values.UnderlyingCollection, base.Serializer.Context); SerializeStack.Add(values.UnderlyingCollection); bool?isReference = contract.IsReference; bool flag = (!isReference.HasValue) ? HasFlag(base.Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays) : isReference.Value; bool flag2 = ShouldWriteType(TypeNameHandling.Arrays, contract, member, collectionValueContract); if (flag || flag2) { writer.WriteStartObject(); if (flag) { writer.WritePropertyName("$id"); writer.WriteValue(base.Serializer.ReferenceResolver.GetReference(this, values.UnderlyingCollection)); } if (flag2) { WriteTypeProperty(writer, values.UnderlyingCollection.GetType()); } writer.WritePropertyName("$values"); } JsonContract collectionValueContract2 = base.Serializer.ContractResolver.ResolveContract(contract.CollectionItemType ?? typeof(object)); writer.WriteStartArray(); int top = writer.Top; int num = 0; foreach (object value in values) { try { JsonContract contractSafe = GetContractSafe(value); if (ShouldWriteReference(value, null, contractSafe)) { WriteReference(writer, value); } else if (CheckForCircularReference(value, null, contract)) { SerializeValue(writer, value, contractSafe, null, collectionValueContract2); } } catch (Exception ex) { if (!IsErrorHandled(values.UnderlyingCollection, contract, num, ex)) { throw; } HandleError(writer, top); } finally { num++; } } writer.WriteEndArray(); if (flag || flag2) { writer.WriteEndObject(); } SerializeStack.RemoveAt(SerializeStack.Count - 1); contract.InvokeOnSerialized(values.UnderlyingCollection, base.Serializer.Context); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { if (value == null) { writer.WriteNull(); return; } writer.WriteStartObject(); var oldPreserveReferencesHandling = serializer.PreserveReferencesHandling; try { serializer.PreserveReferencesHandling = PreserveReferencesHandling.None; foreach (var kvp in (Parameters)value) { writer.WritePropertyName(kvp.Key); var v = kvp.Value; if (v is DateTime dateTime) { if (dateTime.Kind == DateTimeKind.Unspecified) { dateTime = DateTime.SpecifyKind(dateTime, DateTimeKind.Local); } writer.WriteValue(dateTime.GetDefaultRavenFormat()); } else if (v is DateTimeOffset dateTimeOffset) { writer.WriteValue(dateTimeOffset.UtcDateTime.GetDefaultRavenFormat(true)); } else if (v is IEnumerable enumerable) { var oldTypeNameHandling = serializer.TypeNameHandling; try { serializer.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.None; serializer.Serialize(writer, enumerable); } finally { serializer.TypeNameHandling = oldTypeNameHandling; } } else if (IsRavenAssembly(v)) { var oldNullValueHandling = serializer.NullValueHandling; var oldDefaultValueHandling = serializer.DefaultValueHandling; try { serializer.NullValueHandling = NullValueHandling.Ignore; serializer.DefaultValueHandling = DefaultValueHandling.Ignore; serializer.Serialize(writer, v); } finally { serializer.NullValueHandling = oldNullValueHandling; serializer.DefaultValueHandling = oldDefaultValueHandling; } } else { serializer.Serialize(writer, v); } } } finally { serializer.PreserveReferencesHandling = oldPreserveReferencesHandling; } writer.WriteEndObject(); }
/// <summary> /// Serializes the FabricName object to JSON representing NameDescription as defined in Swagger. /// </summary> /// <param name="writer">The <see cref="T: Newtonsoft.Json.JsonWriter" /> to write to.</param> /// <param name="obj">The object to serialize to JSON.</param> internal static void Serialize(JsonWriter writer, FabricName obj) { writer.WriteStartObject(); writer.WriteProperty(obj.ToString(), "Name", JsonWriterExtensions.WriteStringValue); writer.WriteEndObject(); }
/// <summary> /// Writes a geometry to its JSON representation /// </summary> /// <param name="writer">The writer</param> /// <param name="value">The value</param> /// <param name="serializer">The serializer</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { var geom = value as IGeometry; if (geom == null) { writer.WriteNull(); return; } writer.WriteStartObject(); var geomType = ToGeoJsonObject(geom); writer.WritePropertyName("type"); writer.WriteValue(Enum.GetName(typeof(GeoJsonObjectType), geomType)); switch (geomType) { case GeoJsonObjectType.Point: if (serializer.NullValueHandling == NullValueHandling.Include || geom.Coordinate != null) { writer.WritePropertyName("coordinates"); serializer.Serialize(writer, geom.Coordinate); } break; case GeoJsonObjectType.LineString: case GeoJsonObjectType.MultiPoint: var linealCoords = geom.Coordinates; if (serializer.NullValueHandling == NullValueHandling.Include || linealCoords != null) { writer.WritePropertyName("coordinates"); serializer.Serialize(writer, linealCoords); } break; case GeoJsonObjectType.Polygon: var poly = geom as IPolygon; Debug.Assert(poly != null); var polygonCoords = PolygonCoordinates(poly); if (serializer.NullValueHandling == NullValueHandling.Include || polygonCoords != null) { writer.WritePropertyName("coordinates"); serializer.Serialize(writer, polygonCoords); } break; case GeoJsonObjectType.MultiPolygon: var mpoly = geom as IMultiPolygon; Debug.Assert(mpoly != null); var list = new List <List <Coordinate[]> >(); for (int i = 0; i < mpoly.NumGeometries; i++) { list.Add(PolygonCoordinates((IPolygon)mpoly.GetGeometryN(i))); } if (serializer.NullValueHandling == NullValueHandling.Include || list.Count > 0) { writer.WritePropertyName("coordinates"); serializer.Serialize(writer, list); } break; case GeoJsonObjectType.GeometryCollection: var gc = geom as IGeometryCollection; Debug.Assert(gc != null); writer.WritePropertyName("geometries"); serializer.Serialize(writer, gc.Geometries); break; default: var coordinates = new List <Coordinate[]>(); foreach (var geometry in ((IGeometryCollection)geom).Geometries) { coordinates.Add(geometry.Coordinates); } if (serializer.NullValueHandling == NullValueHandling.Include || coordinates.Count > 0) { writer.WritePropertyName("coordinates"); serializer.Serialize(writer, coordinates); } break; } writer.WriteEndObject(); }
private static void WriteDefinitionMap(JsonWriter writer, string definitionMapName, IDictionary <string, JsonSchema> definitionMap, bool sortDefinitions = false, bool addExpressionReferences = false) { if (definitionMap != null && definitionMap.Count > 0) { writer.WritePropertyName(definitionMapName); writer.WriteStartObject(); IEnumerable <string> definitionNames = definitionMap.Keys; if (sortDefinitions) { definitionNames = definitionNames.OrderBy(key => key); } foreach (string definitionName in definitionNames) { JsonSchema definition = definitionMap[definitionName]; bool shouldAddExpressionReference = addExpressionReferences && (definition.JsonType != "string" || (definition.Enum != null && definition.Enum.Count() > 0 && definitionName != "type" && definitionName != "apiVersion")) && (definition.JsonType != "array" || (definitionName != "resources")); if (!shouldAddExpressionReference) { WriteDefinition(writer, definitionName, definition); } else { string definitionDescription = null; writer.WritePropertyName(definitionName); writer.WriteStartObject(); writer.WritePropertyName("oneOf"); writer.WriteStartArray(); if (definition.Description != null) { definitionDescription = definition.Description; definition = definition.Clone(); definition.Description = null; } WriteDefinition(writer, definition); WriteDefinition(writer, new JsonSchema() { Ref = "http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#/definitions/expression" }); writer.WriteEndArray(); WriteProperty(writer, "description", definitionDescription); writer.WriteEndObject(); } } writer.WriteEndObject(); } }
private void SerializeList(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContract collectionValueContract) { contract.InvokeOnSerializing(values.UnderlyingCollection, base.Serializer.Context); this.SerializeStack.Add(values.UnderlyingCollection); bool?isReference = contract.IsReference; bool flag = (!isReference.HasValue ? this.HasFlag(base.Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays) : isReference.Value); bool flag1 = this.ShouldWriteType(TypeNameHandling.Arrays, contract, member, collectionValueContract); if (flag || flag1) { writer.WriteStartObject(); if (flag) { writer.WritePropertyName("$id"); writer.WriteValue(base.Serializer.ReferenceResolver.GetReference(this, values.UnderlyingCollection)); } if (flag1) { this.WriteTypeProperty(writer, values.UnderlyingCollection.GetType()); } writer.WritePropertyName("$values"); } JsonContract jsonContract = base.Serializer.ContractResolver.ResolveContract(contract.CollectionItemType ?? typeof(object)); writer.WriteStartArray(); int top = writer.Top; int num = 0; IEnumerator enumerator = values.GetEnumerator(); try { while (enumerator.MoveNext()) { object current = enumerator.Current; try { try { JsonContract contractSafe = this.GetContractSafe(current); if (this.ShouldWriteReference(current, null, contractSafe)) { this.WriteReference(writer, current); } else if (this.CheckForCircularReference(current, null, contract)) { this.SerializeValue(writer, current, contractSafe, null, jsonContract); } } catch (Exception exception) { if (!base.IsErrorHandled(values.UnderlyingCollection, contract, num, exception)) { throw; } else { this.HandleError(writer, top); } } } finally { num++; } } } finally { IDisposable disposable = enumerator as IDisposable; IDisposable disposable1 = disposable; if (disposable != null) { disposable1.Dispose(); } } writer.WriteEndArray(); if (flag || flag1) { writer.WriteEndObject(); } this.SerializeStack.RemoveAt(this.SerializeStack.Count - 1); contract.InvokeOnSerialized(values.UnderlyingCollection, base.Serializer.Context); }
private void SerializeDictionary(JsonWriter writer, IWrappedDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContract collectionValueContract) { contract.InvokeOnSerializing(values.UnderlyingDictionary, Serializer.Context); SerializeStack.Add(values.UnderlyingDictionary); writer.WriteStartObject(); bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects); if (isReference) { writer.WritePropertyName(JsonTypeReflector.IdPropertyName); writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, values.UnderlyingDictionary)); } if (ShouldWriteType(TypeNameHandling.Objects, contract, member, collectionValueContract)) { WriteTypeProperty(writer, values.UnderlyingDictionary.GetType()); } JsonContract childValuesContract = Serializer.ContractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object)); int initialDepth = writer.Top; // Mono Unity 3.0 fix IDictionary d = values; foreach (DictionaryEntry entry in d) { string propertyName = GetPropertyName(entry); propertyName = (contract.PropertyNameResolver != null) ? contract.PropertyNameResolver(propertyName) : propertyName; try { object value = entry.Value; JsonContract valueContract = GetContractSafe(value); if (ShouldWriteReference(value, null, valueContract)) { writer.WritePropertyName(propertyName); WriteReference(writer, value); } else { if (!CheckForCircularReference(value, null, contract)) { continue; } writer.WritePropertyName(propertyName); SerializeValue(writer, value, valueContract, null, childValuesContract); } } catch (Exception ex) { if (IsErrorHandled(values.UnderlyingDictionary, contract, propertyName, ex)) { HandleError(writer, initialDepth); } else { throw; } } } writer.WriteEndObject(); SerializeStack.RemoveAt(SerializeStack.Count - 1); contract.InvokeOnSerialized(values.UnderlyingDictionary, Serializer.Context); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { if (!(value is NewOrderRequest request)) { throw new BitfinexBadInputException("Can't serialize new order request"); } writer.WriteStartArray(); writer.WriteValue(0); writer.WriteValue("on"); writer.WriteValue((object)null); writer.WriteStartObject(); if (request.Gid.HasValue) { writer.WritePropertyName("gid"); writer.WriteValue(request.Gid.Value); } writer.WritePropertyName("cid"); writer.WriteValue(request.Cid); writer.WritePropertyName("type"); writer.WriteValue(OrderConverter.SerializeType(request.Type)); writer.WritePropertyName("symbol"); writer.WriteValue(request.Symbol); writer.WritePropertyName("amount"); writer.WriteValue(request.Amount.ToString(CultureInfo.InvariantCulture)); if (request.Price.HasValue) { writer.WritePropertyName("price"); writer.WriteValue(request.Price.Value.ToString(CultureInfo.InvariantCulture)); } if (request.PriceTrailing.HasValue) { writer.WritePropertyName("price_trailing"); writer.WriteValue(request.PriceTrailing.Value.ToString(CultureInfo.InvariantCulture)); } if (request.PriceAuxLimit.HasValue) { writer.WritePropertyName("price_aux_limit"); writer.WriteValue(request.PriceAuxLimit.Value.ToString(CultureInfo.InvariantCulture)); } if (request.PriceOcoStop.HasValue) { writer.WritePropertyName("price_oco_stop"); writer.WriteValue(request.PriceOcoStop.Value.ToString(CultureInfo.InvariantCulture)); } if (request.Flags.HasValue) { writer.WritePropertyName("flags"); writer.WriteValue((int)request.Flags); } if (request.TimeInForce.HasValue) { writer.WritePropertyName("tif"); writer.WriteValue(request.TimeInForce.Value.ToString("u")); } InitMeta(request); if (request.Meta != null && request.Meta.Any()) { writer.WritePropertyName("meta"); WriteMeta(request.Meta, writer); } writer.WriteEndObject(); writer.WriteEndArray(); }
public override void WriteStartObject() { _textWriter.WriteStartObject(); _innerWriter.WriteStartObject(); base.WriteStartObject(); }