public void ValueFormatting() { StringBuilder sb = new StringBuilder(); StringWriter sw = new StringWriter(sb); using (JsonWriter jsonWriter = new JsonWriter(sw)) { jsonWriter.WriteStartArray(); jsonWriter.WriteValue('@'); jsonWriter.WriteValue("\r\n\t\f\b?{\\r\\n\"\'"); jsonWriter.WriteValue(true); jsonWriter.WriteValue(10); jsonWriter.WriteValue(10.99); jsonWriter.WriteValue(0.99); jsonWriter.WriteValue(0.000000000000000001d); jsonWriter.WriteValue(0.000000000000000001m); jsonWriter.WriteValue(null); jsonWriter.WriteValue("This is a string."); jsonWriter.WriteNull(); jsonWriter.WriteUndefined(); jsonWriter.WriteEndArray(); } const string expected = @"[""@"",""\r\n\t\f\b?{\\r\\n\""'"",true,10,10.99,0.99,1E-18,0.000000000000000001,,""This is a string."",null,undefined]"; string result = sb.ToString(); Console.WriteLine("ValueFormatting"); Console.WriteLine(result); Assert.AreEqual(expected, result); }
/// <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 void WritesNull() { var sw = new StringWriter(); var writer = new JsonWriter(sw); writer.WriteNull(); Assert.AreEqual("null", sw.ToString()); }
/// <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); } }
/// <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> /// 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); } }
/// <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 didn't have an option against it // fallback to writing number value writer.WriteValue(value); } else { if (CamelCaseText) enumName = StringUtils.ToCamelCase(enumName); writer.WriteValue(enumName); } }
/// <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(); }
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"); } }
/// <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 (writer == null) throw new ArgumentNullException("writer"); if (value == null) { writer.WriteNull(); return; } var data = GetByteArray(value); writer.WriteValue(data); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { NameContainer nameContainer = value as NameContainer; if (nameContainer != null) writer.WriteValue(nameContainer.Value); else writer.WriteNull(); }
public virtual void Export(object value, JsonWriter writer) { if (writer == null) throw new ArgumentNullException("writer"); if (value == null) writer.WriteNull(); else ExportValue(value, writer); }
public override void Write(JsonWriter writer, object value) { if (value == null) writer.WriteNull(); else { var m = value as LinearRegressionModel; base.Write(writer, m); writer.WriteProperty(nameof(m.Theta), m.Theta); } }
// Token: 0x0600017F RID: 383 // RVA: 0x0002B420 File Offset: 0x00029620 public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { if (value == null) { writer.WriteNull(); return; } byte[] byteArray = this.GetByteArray(value); writer.WriteValue(byteArray); }
private void SerializeValue(JsonWriter writer, object value, JsonConverter memberConverter) { JsonConverter converter = memberConverter; if (value == null) { writer.WriteNull(); } else if (converter != null || _serializer.HasClassConverter(value.GetType(), out converter) || _serializer.HasMatchingConverter(value.GetType(), out converter)) { SerializeConvertable(writer, converter, value); } else if (JsonConvert.IsJsonPrimitive(value)) { writer.WriteValue(value); } else if (value is JToken) { ((JToken)value).WriteTo(writer, (_serializer.Converters != null) ? _serializer.Converters.ToArray() : null); } else if (value is JsonRaw) { writer.WriteRawValue(((JsonRaw)value).Content); } else { JsonContract contract = _serializer.ContractResolver.ResolveContract(value.GetType()); if (contract is JsonObjectContract) { SerializeObject(writer, value, (JsonObjectContract)contract); } else if (contract is JsonDictionaryContract) { SerializeDictionary(writer, (IDictionary)value, (JsonDictionaryContract)contract); } else if (contract is JsonArrayContract) { if (value is IList) { SerializeList(writer, (IList)value, (JsonArrayContract)contract); } else if (value is IEnumerable) { SerializeEnumerable(writer, (IEnumerable)value, (JsonArrayContract)contract); } else { throw new Exception("Cannot serialize '{0}' into a JSON array. Type does not implement IEnumerable.".FormatWith(CultureInfo.InvariantCulture, value.GetType())); } } } }
public override void Write(JsonWriter writer, object value) { if (value == null) writer.WriteNull(); else { var t = value as Tree; base.Write(writer, t); writer.WriteProperty(nameof(t.Root), t.Root); } }
/// <summary> /// Serializes a generic model object to the stream. /// </summary> /// <param name="writer">A JSON Writer.</param> /// <param name="value"></param> public override void Write(JsonWriter writer, object value) { if (value == null) writer.WriteNull(); else { var model = (numl.Supervised.Model)value; writer.WriteProperty(nameof(model.Descriptor), model.Descriptor); writer.WriteProperty(nameof(model.NormalizeFeatures), model.NormalizeFeatures); writer.WriteProperty(nameof(model.FeatureNormalizer), model.FeatureNormalizer?.GetType().FullName); writer.WriteProperty(nameof(model.FeatureProperties), model.FeatureProperties); } }
/// <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; } var data = GetByteArray(value); writer.WriteValue(data); }
// Token: 0x060001B5 RID: 437 // RVA: 0x00006EA4 File Offset: 0x000050A4 public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { if (value == null) { writer.WriteNull(); return; } if (!(value is Version)) { throw new JsonSerializationException("Expected Version object value"); } writer.WriteValue(value.ToString()); }
public virtual void Export(ExportContext context, object value, JsonWriter writer) { if (context == null) throw new ArgumentNullException("context"); if (writer == null) throw new ArgumentNullException("writer"); if (JsonNull.LogicallyEquals(value)) writer.WriteNull(); else ExportValue(context, value, writer); }
/// <summary> /// Serializes the given Summary object to the given stream. /// </summary> /// <param name="writer">A JSON Writer object.</param> /// <param name="value">A Summary object.</param> public override void Write(JsonWriter writer, object value) { if (value == null) writer.WriteNull(); else { var summary = (Summary)value; writer.WriteProperty(nameof(Summary.Average), summary.Average); writer.WriteProperty(nameof(Summary.Minimum), summary.Minimum); writer.WriteProperty(nameof(Summary.Median), summary.Median); writer.WriteProperty(nameof(Summary.Maximum), summary.Maximum); writer.WriteProperty(nameof(Summary.StandardDeviation), summary.StandardDeviation); } }
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"); } }
/// <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; } byte[] data = value as byte[]; if (data == null) data = GetByteArray(value); writer.WriteValue(Convert.ToBase64String(data)); }
/// <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(); } else if (value is Version) { writer.WriteValue(value.ToString()); } else { throw new Exception("Expected Version object 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) { 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 writer.WriteValue(enumName); }
/// <summary> /// Writes the Neural Network object to the stream. /// </summary> /// <param name="writer">Stream to write to.</param> /// <param name="value">Neural Network object to write.</param> public override void Write(JsonWriter writer, object value) { if (value == null) writer.WriteNull(); else { var network = (Network)value; // write out nodes writer.WriteArrayProperty("Nodes", network.GetVertices().ToArray()); // write out all edges writer.WriteArrayProperty("Edges", network.GetEdges().ToArray()); } }
/// <summary> /// Serializes neural network model /// </summary> /// <param name="writer">JsonWriter</param> /// <param name="value">Model to Serialize</param> public override void Write(JsonWriter writer, object value) { if (value == null) writer.WriteNull(); else { var model = (NeuralNetworkModel)value; base.Write(writer, model); // write out function writer.WriteProperty(nameof(model.OutputFunction), model.OutputFunction?.GetType().FullName); // write out network writer.WriteProperty(nameof(model.Network), model.Network); } }
public static void Export(object value, JsonWriter writer) { if (writer == null) throw new ArgumentNullException("writer"); if (value == null) { writer.WriteNull(); return; } IJsonExporter exporter = TryGetExporter(value.GetType()); if (exporter != null) exporter.Export(value, writer); else writer.WriteString(value.ToString()); }
protected override void FormatEnumerable(IEnumerable enumerable, JsonWriter writer) { if (writer == null) throw new ArgumentNullException("writer"); if (JNull.LogicallyEquals(enumerable)) { writer.WriteNull(); return; } NameValueCollection collection = enumerable as NameValueCollection; if (collection != null) FormatNameValueCollection(collection, writer); else base.FormatEnumerable(enumerable, writer); }
public void Serialize(ref JsonWriter writer, TDictionary value, IJsonFormatterResolver formatterResolver) { if (value == null) { writer.WriteNull(); return; } else { var keyFormatter = formatterResolver.GetFormatterWithVerify <TKey>() as IObjectPropertyNameFormatter <TKey>; var valueFormatter = formatterResolver.GetFormatterWithVerify <TValue>(); writer.WriteBeginObject(); var e = GetSourceEnumerator(value); try { if (keyFormatter != null) { if (e.MoveNext()) { var item = e.Current; keyFormatter.SerializeToPropertyName(ref writer, item.Key, formatterResolver); writer.WriteNameSeparator(); valueFormatter.Serialize(ref writer, item.Value, formatterResolver); } else { goto END; } while (e.MoveNext()) { writer.WriteValueSeparator(); var item = e.Current; keyFormatter.SerializeToPropertyName(ref writer, item.Key, formatterResolver); writer.WriteNameSeparator(); valueFormatter.Serialize(ref writer, item.Value, formatterResolver); } } else { if (e.MoveNext()) { var item = e.Current; writer.WriteString(item.Key.ToString()); writer.WriteNameSeparator(); valueFormatter.Serialize(ref writer, item.Value, formatterResolver); } else { goto END; } while (e.MoveNext()) { writer.WriteValueSeparator(); var item = e.Current; writer.WriteString(item.Key.ToString()); writer.WriteNameSeparator(); valueFormatter.Serialize(ref writer, item.Value, formatterResolver); } } } finally { e.Dispose(); } END: writer.WriteEndObject(); } }
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(n => n.LocalName == node.LocalName) && node.ChildNodes.Count > 0) { SerializeGroupedNodes(writer, node, manager, false); } else { foreach (IXmlNode attribute in node.Attributes) { if (attribute.NamespaceURI == "http://www.w3.org/2000/xmlns/") { string prefix = (attribute.LocalName != "xmlns") ? attribute.LocalName : string.Empty; 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) { // 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 { writer.WriteStartObject(); for (int i = 0; i < node.Attributes.Count; i++) { SerializeNode(writer, node.Attributes[i], manager, true); } SerializeGroupedNodes(writer, node, manager, 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 == JsonNamespaceUri) { return; } if (node.NamespaceURI == JsonNamespaceUri) { if (node.LocalName == "Array") { return; } } if (writePropertyName) { writer.WritePropertyName(GetPropertyName(node, manager)); } writer.WriteValue(node.Value); break; case XmlNodeType.XmlDeclaration: IXmlDeclaration declaration = (IXmlDeclaration)node; writer.WritePropertyName(GetPropertyName(node, manager)); 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 void Serialize(ref JsonWriter writer, IAnalyzer value, IJsonFormatterResolver formatterResolver) { if (value == null) { writer.WriteNull(); return; } switch (value.Type) { case "stop": Serialize <IStopAnalyzer>(ref writer, value, formatterResolver); break; case "standard": Serialize <IStandardAnalyzer>(ref writer, value, formatterResolver); break; case "snowball": Serialize <ISnowballAnalyzer>(ref writer, value, formatterResolver); break; case "pattern": Serialize <IPatternAnalyzer>(ref writer, value, formatterResolver); break; case "keyword": Serialize <IKeywordAnalyzer>(ref writer, value, formatterResolver); break; case "whitespace": Serialize <IWhitespaceAnalyzer>(ref writer, value, formatterResolver); break; case "simple": Serialize <ISimpleAnalyzer>(ref writer, value, formatterResolver); break; case "fingerprint": Serialize <IFingerprintAnalyzer>(ref writer, value, formatterResolver); break; case "kuromoji": Serialize <IKuromojiAnalyzer>(ref writer, value, formatterResolver); break; case "nori": Serialize <INoriAnalyzer>(ref writer, value, formatterResolver); break; case "icu_analyzer": Serialize <IIcuAnalyzer>(ref writer, value, formatterResolver); break; case "custom": Serialize <ICustomAnalyzer>(ref writer, value, formatterResolver); break; default: Serialize <ILanguageAnalyzer>(ref writer, value, formatterResolver); break; } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializerWriter internalWriter) { if (value == null) { writer.WriteNull(); return; } var m = (Matrix4x4)value; writer.WriteStartObject(); writer.WritePropertyName("m00"); writer.WriteValue(m.m00); writer.WritePropertyName("m01"); writer.WriteValue(m.m01); writer.WritePropertyName("m02"); writer.WriteValue(m.m02); writer.WritePropertyName("m03"); writer.WriteValue(m.m03); writer.WritePropertyName("m10"); writer.WriteValue(m.m10); writer.WritePropertyName("m11"); writer.WriteValue(m.m11); writer.WritePropertyName("m12"); writer.WriteValue(m.m12); writer.WritePropertyName("m13"); writer.WriteValue(m.m13); writer.WritePropertyName("m20"); writer.WriteValue(m.m20); writer.WritePropertyName("m21"); writer.WriteValue(m.m21); writer.WritePropertyName("m22"); writer.WriteValue(m.m22); writer.WritePropertyName("m23"); writer.WriteValue(m.m23); writer.WritePropertyName("m30"); writer.WriteValue(m.m30); writer.WritePropertyName("m31"); writer.WriteValue(m.m31); writer.WritePropertyName("m32"); writer.WriteValue(m.m32); writer.WritePropertyName("m33"); writer.WriteValue(m.m33); writer.WriteEnd(); }
public override void WriteTo(JsonWriter writer, params JsonConverter[] converters) { switch (_valueType) { case JTokenType.Comment: writer.WriteComment(_value.ToString()); return; case JTokenType.Raw: writer.WriteRawValue((_value != null) ? _value.ToString() : null); return; case JTokenType.Null: writer.WriteNull(); return; case JTokenType.Undefined: writer.WriteUndefined(); return; } JsonConverter matchingConverter; if (_value != null && (matchingConverter = JsonSerializer.GetMatchingConverter(converters, _value.GetType())) != null) { matchingConverter.WriteJson(writer, _value, new JsonSerializer()); return; } switch (_valueType) { case JTokenType.Integer: writer.WriteValue(Convert.ToInt64(_value, CultureInfo.InvariantCulture)); break; case JTokenType.Float: writer.WriteValue(Convert.ToDouble(_value, CultureInfo.InvariantCulture)); break; case JTokenType.String: writer.WriteValue((_value != null) ? _value.ToString() : null); break; case JTokenType.Boolean: writer.WriteValue(Convert.ToBoolean(_value, CultureInfo.InvariantCulture)); break; case JTokenType.Date: if (_value is DateTimeOffset) { writer.WriteValue((DateTimeOffset)_value); } else { writer.WriteValue(Convert.ToDateTime(_value, CultureInfo.InvariantCulture)); } break; case JTokenType.Bytes: writer.WriteValue((byte[])_value); break; case JTokenType.Guid: case JTokenType.Uri: case JTokenType.TimeSpan: writer.WriteValue((_value != null) ? _value.ToString() : null); break; default: throw MiscellaneousUtils.CreateArgumentOutOfRangeException("TokenType", _valueType, "Unexpected token type."); } }
public void Serialize(ref JsonWriter writer, TDictionary value, IJsonFormatterResolver formatterResolver) { var enumerable = (IEnumerable <KeyValuePair <TKey, TValue> >)value; if (enumerable == null) { writer.WriteNull(); return; } var settings = formatterResolver.GetConnectionSettings(); var seenEntries = new Dictionary <string, TValue>(value.Count()); foreach (var entry in enumerable) { if (SkipValue(entry)) // TODO: pass _connectionSettingsValues and configure Null Handling on this { continue; } string key; if (_keyIsString) { key = entry.Key?.ToString(); } else if (settings == null) { key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture); } else if (_keyIsField) { var fieldName = entry.Key as Field; key = settings.Inferrer.Field(fieldName); } else if (_keyIsPropertyName) { var propertyName = entry.Key as PropertyName; if (propertyName?.Property != null && settings.PropertyMappings.TryGetValue(propertyName.Property, out var mapping) && mapping.Ignore) { continue; } key = settings.Inferrer.PropertyName(propertyName); } else if (_keyIsIndexName) { var indexName = entry.Key as IndexName; key = settings.Inferrer.IndexName(indexName); } else if (_keyIsRelationName) { var typeName = entry.Key as RelationName; key = settings.Inferrer.RelationName(typeName); } else { key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture); } if (key != null) { seenEntries[key] = entry.Value; } } var formatter = formatterResolver.GetFormatter <Dictionary <string, TValue> >(); formatter.Serialize(ref writer, seenEntries, formatterResolver); }
public void Serialize(ref JsonWriter writer, T value, IJsonFormatterResolver formatterResolver) { writer.WriteNull(); }
public static void WriteJson(JsonWriter writer, object value, JsonSerializer serializer, Func <Type, bool> shouldConvertDictionary, Action <JsonWriter, object, JsonSerializer> recurse, Func <IProvideSerialization, double> orderSerializationAttrs) { if (value is IReferenceable) { var id = (value as IReferenceable).id; WriteId(id); //writer.WriteValue(id); return; } if (value is IReferences) { writer.WriteStartArray(); Guid[] ids = (value as IReferences).ids .Select( id => { WriteId(id); //writer.WriteValue(id); return(id); }) .ToArray(); writer.WriteEndArray(); return; } if (value is IReferenceableOptional) { var id = (value as IReferenceableOptional).id; WriteId(id); //writer.WriteValue(id); return; } if (!value.TryGetType(out Type valueType)) { writer.WriteNull(); return; } if (valueType.IsSubClassOfGeneric(typeof(IDictionary <,>))) { writer.WriteStartObject(); foreach (var kvpObj in value.DictionaryKeyValuePairs()) { var keyValue = kvpObj.Key; var propertyName = (keyValue is IReferenceable) ? (keyValue as IReferenceable).id.ToString() : keyValue.ToString(); writer.WritePropertyName(propertyName); var valueValue = kvpObj.Value; var valueValueType = valueType.GenericTypeArguments.Last(); if (shouldConvertDictionary(valueValueType)) { recurse(writer, valueValue, serializer); continue; } writer.WriteValue(valueValue); } writer.WriteEndObject(); return; } if (value is Type) { var typeValue = (value as Type); var serializationAttrs = typeValue .GetAttributesInterface <IProvideSerialization>(); if (serializationAttrs.Any()) { var serializationAttr = serializationAttrs .OrderByDescending(orderSerializationAttrs) .First(); writer.WriteValue(serializationAttr.ContentType); return; } var stringType = typeValue.GetClrString(); writer.WriteValue(stringType); return; } if (valueType.IsEnum) { var stringValue = Enum.GetName(valueType, value); writer.WriteValue(stringValue); return; } serializer.Serialize(writer, value); void WriteId(Guid?idMaybe) { if (!idMaybe.HasValue) { writer.WriteValue((string)null); return; } var id = idMaybe.Value; writer.WriteValue(id); } }
/// <summary> /// Writes this token to a <see cref="JsonWriter"/>. /// </summary> /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param> /// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param> public override void WriteTo(JsonWriter writer, params JsonConverter[] converters) { if (converters != null && converters.Length > 0 && _value != null) { JsonConverter matchingConverter = JsonSerializer.GetMatchingConverter(converters, _value.GetType()); if (matchingConverter != null) { matchingConverter.WriteJson(writer, _value, new JsonSerializer()); return; } } switch (_valueType) { case JTokenType.Comment: writer.WriteComment((_value != null) ? _value.ToString() : null); return; case JTokenType.Raw: writer.WriteRawValue((_value != null) ? _value.ToString() : null); return; case JTokenType.Null: writer.WriteNull(); return; case JTokenType.Undefined: writer.WriteUndefined(); return; case JTokenType.Integer: writer.WriteValue(Convert.ToInt64(_value, CultureInfo.InvariantCulture)); return; case JTokenType.Float: if (_value is decimal) { writer.WriteValue((decimal)_value); } else if (_value is double) { writer.WriteValue((double)_value); } else if (_value is float) { writer.WriteValue((float)_value); } else { writer.WriteValue(Convert.ToDouble(_value, CultureInfo.InvariantCulture)); } return; case JTokenType.String: writer.WriteValue((_value != null) ? _value.ToString() : null); return; case JTokenType.Boolean: writer.WriteValue(Convert.ToBoolean(_value, CultureInfo.InvariantCulture)); return; case JTokenType.Date: #if !PocketPC && !NET20 if (_value is DateTimeOffset) { writer.WriteValue((DateTimeOffset)_value); } else #endif writer.WriteValue(Convert.ToDateTime(_value, CultureInfo.InvariantCulture)); return; case JTokenType.Bytes: writer.WriteValue((byte[])_value); return; case JTokenType.Guid: case JTokenType.Uri: case JTokenType.TimeSpan: writer.WriteValue((_value != null) ? _value.ToString() : null); return; } throw MiscellaneousUtils.CreateArgumentOutOfRangeException("TokenType", _valueType, "Unexpected token type."); }
public override unsafe void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { // Also serves as a null check. if (!(value is Stream stream)) { writer.WriteNull(); return; } if (!stream.CanRead) { throw new InvalidDataException("The stream is not readable."); } StringBuilder base64Builder; if (!stream.CanSeek) { // If the stream isn't seekable all we can do is start reading from it. base64Builder = new StringBuilder(HEADER); } else { // Check if it's an empty attachment. if (stream.Length == 0) { writer.WriteValue(HEADER); return; } // Check if the user didn't rewind the stream. if (stream.Position == stream.Length) { throw new InvalidDataException("The stream's position is the same as its length. Did you forget to rewind it?"); } // Check if the stream is a memory stream and the underlying buffer is retrievable, // so we can skip the reading as all of the memory is already allocated anyways. if (stream is MemoryStream memoryStream && memoryStream.TryGetBuffer(out var memoryStreamBuffer)) { var base64 = string.Concat(HEADER, Convert.ToBase64String(memoryStreamBuffer.AsSpan())); writer.WriteValue(base64); return; } // If the stream is seekable we can use its length and position to roughly calculate its base64 length. base64Builder = new StringBuilder(HEADER, (int)((stream.Length - stream.Position) * 1.37f) + HEADER.Length); } // TODO: Do something about both not fully downloaded http streams // and buffer underflowing. // Allocate a 3 bytes span buffer for reading data from the stream // and a 4 chars span buffer for the base64 encoded bytes. Span <byte> byteSpan = stackalloc byte[3]; Span <char> charSpan = stackalloc char[4]; int bytesRead; while ((bytesRead = stream.Read(byteSpan)) != 0) { if (!Convert.TryToBase64Chars(byteSpan.Slice(0, bytesRead), charSpan, out var charsWritten)) { throw new InvalidDataException("The stream could not be converted to base64."); } base64Builder.Append(charSpan.Slice(0, charsWritten)); } writer.WriteValue(base64Builder.ToString()); }
/// <summary> /// Writes this token to a <see cref="JsonWriter"/>. /// </summary> /// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param> /// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param> public override void WriteTo(JsonWriter writer, params JsonConverter[] converters) { if (converters != null && converters.Length > 0 && _value != null) { JsonConverter matchingConverter = JsonSerializer.GetMatchingConverter(converters, _value.GetType()); if (matchingConverter != null && matchingConverter.CanWrite) { matchingConverter.WriteJson(writer, _value, JsonSerializer.CreateDefault()); return; } } switch (_valueType) { case JTokenType.Comment: writer.WriteComment((_value != null) ? _value.ToString() : null); return; case JTokenType.Raw: writer.WriteRawValue((_value != null) ? _value.ToString() : null); return; case JTokenType.Null: writer.WriteNull(); return; case JTokenType.Undefined: writer.WriteUndefined(); return; case JTokenType.Integer: if (_value is int) { writer.WriteValue((int)_value); } else if (_value is long) { writer.WriteValue((long)_value); } else if (_value is ulong) { writer.WriteValue((ulong)_value); } #if !(NET20 || NET35 || PORTABLE40 || PORTABLE) || NETSTANDARD1_1 else if (_value is BigInteger) { writer.WriteValue((BigInteger)_value); } #endif else { writer.WriteValue(Convert.ToInt64(_value, CultureInfo.InvariantCulture)); } return; case JTokenType.Float: if (_value is decimal) { writer.WriteValue((decimal)_value); } else if (_value is double) { writer.WriteValue((double)_value); } else if (_value is float) { writer.WriteValue((float)_value); } else { writer.WriteValue(Convert.ToDouble(_value, CultureInfo.InvariantCulture)); } return; case JTokenType.String: writer.WriteValue((_value != null) ? _value.ToString() : null); return; case JTokenType.Boolean: writer.WriteValue(Convert.ToBoolean(_value, CultureInfo.InvariantCulture)); return; case JTokenType.Date: #if !NET20 if (_value is DateTimeOffset) { writer.WriteValue((DateTimeOffset)_value); } else #endif { writer.WriteValue(Convert.ToDateTime(_value, CultureInfo.InvariantCulture)); } return; case JTokenType.Bytes: writer.WriteValue((byte[])_value); return; case JTokenType.Guid: writer.WriteValue((_value != null) ? (Guid?)_value : null); return; case JTokenType.TimeSpan: writer.WriteValue((_value != null) ? (TimeSpan?)_value : null); return; case JTokenType.Uri: writer.WriteValue((Uri)_value); return; } throw MiscellaneousUtils.CreateArgumentOutOfRangeException("TokenType", _valueType, "Unexpected token type."); }
public void Serialize(ref JsonWriter writer, object value, IJsonFormatterResolver formatterResolver) { if (value == null) { writer.WriteNull(); return; } var type = value.GetType(); if (type == typeof(object)) { // serialize to empty object writer.WriteBeginObject(); writer.WriteEndObject(); return; } KeyValuePair <object, Tuple <SerializeMethod, bool> > formatterAndDelegate; if (!serializers.TryGetValue(type, out formatterAndDelegate)) { lock (serializers) { if (!serializers.TryGetValue(type, out formatterAndDelegate)) { object formatter = null; foreach (var innerResolver in innerResolvers) { formatter = innerResolver.GetFormatterDynamic(type); if (formatter != null) { break; } } if (formatter == null) { throw new FormatterNotRegisteredException(type.FullName + " is not registered in this resolver. resolvers:" + string.Join(", ", innerResolvers.Select(x => x.GetType().Name).ToArray())); } var t = type; { var dm = new DynamicMethod("Serialize", null, new[] { typeof(object), typeof(JsonWriter).MakeByRefType(), typeof(object), typeof(IJsonFormatterResolver) }, type.Module, true); var il = dm.GetILGenerator(); // delegate void SerializeMethod(object dynamicFormatter, ref JsonWriter writer, object value, IJsonFormatterResolver formatterResolver); il.EmitLdarg(0); il.Emit(OpCodes.Castclass, typeof(IJsonFormatter <>).MakeGenericType(t)); il.EmitLdarg(1); il.EmitLdarg(2); il.EmitUnboxOrCast(t); il.EmitLdarg(3); il.EmitCall(Resolvers.Internal.DynamicObjectTypeBuilder.EmitInfo.Serialize(t)); il.Emit(OpCodes.Ret); var writeTypeName = BuiltinResolver.HasFormatter(type); formatterAndDelegate = new KeyValuePair <object, Tuple <SerializeMethod, bool> >(formatter, Tuple.Create((SerializeMethod)dm.CreateDelegate(typeof(SerializeMethod)), writeTypeName)); } serializers.TryAdd(t, formatterAndDelegate); } } } if (formatterAndDelegate.Value.Item2) { writer.WriteBeginObject(); writer.WritePropertyName("$type"); var typeName = SubtractFullNameRegex.Replace(type.AssemblyQualifiedName, ""); writer.WriteString(typeName); writer.WriteValueSeparator(); writer.WritePropertyName("$value"); } formatterAndDelegate.Value.Item1(formatterAndDelegate.Key, ref writer, value, formatterResolver); if (formatterAndDelegate.Value.Item2) { writer.WriteEndObject(); } }
public void Serialize(ref JsonWriter writer, ILifecycleActions value, IJsonFormatterResolver formatterResolver) { if (value == null) { writer.WriteNull(); return; } writer.WriteBeginObject(); var count = 0; foreach (var action in value) { if (count > 0) { writer.WriteValueSeparator(); } writer.WritePropertyName(action.Key); switch (action.Key) { case "allocate": Serialize <IAllocateLifecycleAction>(ref writer, action.Value, formatterResolver); break; case "delete": Serialize <IDeleteLifecycleAction>(ref writer, action.Value, formatterResolver); break; case "forcemerge": Serialize <IForceMergeLifecycleAction>(ref writer, action.Value, formatterResolver); break; case "freeze": Serialize <IFreezeLifecycleAction>(ref writer, action.Value, formatterResolver); break; case "readonly": Serialize <IReadOnlyLifecycleAction>(ref writer, action.Value, formatterResolver); break; case "rollover": Serialize <IRolloverLifecycleAction>(ref writer, action.Value, formatterResolver); break; case "set_priority": Serialize <ISetPriorityLifecycleAction>(ref writer, action.Value, formatterResolver); break; case "shrink": Serialize <IShrinkLifecycleAction>(ref writer, action.Value, formatterResolver); break; case "unfollow": Serialize <IUnfollowLifecycleAction>(ref writer, action.Value, formatterResolver); break; case "wait_for_snapshot": Serialize <IWaitForSnapshotLifecycleAction>(ref writer, action.Value, formatterResolver); break; default: DynamicObjectResolver.ExcludeNullCamelCase.GetFormatter <ILifecycleAction>() .Serialize(ref writer, action.Value, formatterResolver); break; } count++; } writer.WriteEndObject(); }
public void Serialize(ref JsonWriter writer, IMovingAverageAggregation value, IJsonFormatterResolver formatterResolver) { if (value == null) { writer.WriteNull(); return; } writer.WriteBeginObject(); var propertyWritten = false; if (value.BucketsPath != null) { writer.WritePropertyName("buckets_path"); var formatter = formatterResolver.GetFormatter <IBucketsPath>(); formatter.Serialize(ref writer, value.BucketsPath, formatterResolver); propertyWritten = true; } if (value.GapPolicy != null) { if (propertyWritten) { writer.WriteValueSeparator(); } writer.WritePropertyName("gap_policy"); writer.WriteString(value.GapPolicy.GetStringValue()); propertyWritten = true; } if (!value.Format.IsNullOrEmpty()) { if (propertyWritten) { writer.WriteValueSeparator(); } writer.WritePropertyName("format"); writer.WriteString(value.Format); propertyWritten = true; } if (value.Window != null) { if (propertyWritten) { writer.WriteValueSeparator(); } writer.WritePropertyName("window"); writer.WriteInt32(value.Window.Value); propertyWritten = true; } if (value.Minimize != null) { if (propertyWritten) { writer.WriteValueSeparator(); } writer.WritePropertyName("minimize"); writer.WriteBoolean(value.Minimize.Value); propertyWritten = true; } if (value.Predict != null) { if (propertyWritten) { writer.WriteValueSeparator(); } writer.WritePropertyName("predict"); writer.WriteInt32(value.Predict.Value); propertyWritten = true; } if (value.Model != null) { if (propertyWritten) { writer.WriteValueSeparator(); } writer.WritePropertyName("model"); writer.WriteString(value.Model.Name); writer.WriteValueSeparator(); writer.WritePropertyName("settings"); switch (value.Model.Name) { case "ewma": Serialize(ref writer, (IEwmaModel)value.Model, formatterResolver); break; case "linear": Serialize(ref writer, (ILinearModel)value.Model, formatterResolver); break; case "simple": Serialize(ref writer, (ISimpleModel)value.Model, formatterResolver); break; case "holt": Serialize(ref writer, (IHoltLinearModel)value.Model, formatterResolver); break; case "holt_winters": Serialize(ref writer, (IHoltWintersModel)value.Model, formatterResolver); break; default: Serialize(ref writer, value.Model, formatterResolver); break; } } writer.WriteEndObject(); }
public override void WriteTo(JsonWriter writer, JsonConverterCollection converters) { switch (_valueType) { case JTokenType.Comment: writer.WriteComment(_value.ToString()); return; case JTokenType.Raw: writer.WriteRawValue((_value != null) ? _value.ToString() : null); return; case JTokenType.Null: writer.WriteNull(); return; case JTokenType.Undefined: writer.WriteUndefined(); return; } if (_value != null) { Type typeToFind = _value.GetType(); // If we are using the default converters we will try to avoid repeatedly check the same types as // GetMatchingConverter is a costly call with a very low probability to hit (less than 1% in real scenarios). JsonConverter matchingConverter = JsonConverterCache.GetMatchingConverter(converters, typeToFind); if (matchingConverter != null) { matchingConverter.WriteJson(writer, _value, JsonExtensions.CreateDefaultJsonSerializer()); return; } } switch (_valueType) { case JTokenType.Integer: writer.WriteValue(Convert.ToInt64(_value, CultureInfo.InvariantCulture)); return; case JTokenType.Float: if (_value is decimal) { writer.WriteValue((decimal)_value); return; } if (_value is float) { writer.WriteValue((float)_value); return; } writer.WriteValue(Convert.ToDouble(_value, CultureInfo.InvariantCulture)); return; case JTokenType.String: writer.WriteValue((_value != null) ? _value.ToString() : null); return; case JTokenType.Boolean: writer.WriteValue(Convert.ToBoolean(_value, CultureInfo.InvariantCulture)); return; case JTokenType.Date: #if !PocketPC && !NET20 if (_value is DateTimeOffset) { writer.WriteValue((DateTimeOffset)_value); } else #endif writer.WriteValue(Convert.ToDateTime(_value, CultureInfo.InvariantCulture)); return; case JTokenType.Bytes: writer.WriteValue((byte[])_value); return; case JTokenType.Guid: case JTokenType.Uri: case JTokenType.TimeSpan: writer.WriteValue((_value != null) ? _value.ToString() : null); return; } throw MiscellaneousUtils.CreateArgumentOutOfRangeException("TokenType", _valueType, "Unexpected token type."); }
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(); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { writer.WriteNull(); }
public void Serialize(ref JsonWriter writer, IProperty value, IJsonFormatterResolver formatterResolver) { if (value == null) { writer.WriteNull(); return; } switch (value) { case ITextProperty textProperty: Serialize(ref writer, textProperty, formatterResolver); break; case IKeywordProperty keywordProperty: Serialize(ref writer, keywordProperty, formatterResolver); break; case INumberProperty numberProperty: Serialize(ref writer, numberProperty, formatterResolver); break; case IDateProperty dateProperty: Serialize(ref writer, dateProperty, formatterResolver); break; case IBooleanProperty booleanProperty: Serialize(ref writer, booleanProperty, formatterResolver); break; case INestedProperty nestedProperty: Serialize(ref writer, nestedProperty, formatterResolver); break; case IObjectProperty objectProperty: Serialize(ref writer, objectProperty, formatterResolver); break; case ISearchAsYouTypeProperty searchAsYouTypeProperty: Serialize(ref writer, searchAsYouTypeProperty, formatterResolver); break; case IDateNanosProperty dateNanosProperty: Serialize(ref writer, dateNanosProperty, formatterResolver); break; case IBinaryProperty binaryProperty: Serialize(ref writer, binaryProperty, formatterResolver); break; case IIpProperty ipProperty: Serialize(ref writer, ipProperty, formatterResolver); break; case IGeoPointProperty geoPointProperty: Serialize(ref writer, geoPointProperty, formatterResolver); break; case IGeoShapeProperty geoShapeProperty: Serialize(ref writer, geoShapeProperty, formatterResolver); break; case IShapeProperty shapeProperty: Serialize(ref writer, shapeProperty, formatterResolver); break; case ICompletionProperty completionProperty: Serialize(ref writer, completionProperty, formatterResolver); break; case ITokenCountProperty tokenCountProperty: Serialize(ref writer, tokenCountProperty, formatterResolver); break; case IMurmur3HashProperty murmur3HashProperty: Serialize(ref writer, murmur3HashProperty, formatterResolver); break; case IPercolatorProperty percolatorProperty: Serialize(ref writer, percolatorProperty, formatterResolver); break; case IDateRangeProperty dateRangeProperty: Serialize(ref writer, dateRangeProperty, formatterResolver); break; case IDoubleRangeProperty doubleRangeProperty: Serialize(ref writer, doubleRangeProperty, formatterResolver); break; case IFloatRangeProperty floatRangeProperty: Serialize(ref writer, floatRangeProperty, formatterResolver); break; case IIntegerRangeProperty integerRangeProperty: Serialize(ref writer, integerRangeProperty, formatterResolver); break; case ILongRangeProperty longRangeProperty: Serialize(ref writer, longRangeProperty, formatterResolver); break; case IIpRangeProperty ipRangeProperty: Serialize(ref writer, ipRangeProperty, formatterResolver); break; case IJoinProperty joinProperty: Serialize(ref writer, joinProperty, formatterResolver); break; case IFieldAliasProperty fieldAliasProperty: Serialize(ref writer, fieldAliasProperty, formatterResolver); break; case IRankFeatureProperty rankFeatureProperty: Serialize(ref writer, rankFeatureProperty, formatterResolver); break; case IRankFeaturesProperty rankFeaturesProperty: Serialize(ref writer, rankFeaturesProperty, formatterResolver); break; case IFlattenedProperty flattenedProperty: Serialize(ref writer, flattenedProperty, formatterResolver); break; case IHistogramProperty histogramProperty: Serialize(ref writer, histogramProperty, formatterResolver); break; case IGenericProperty genericProperty: Serialize(ref writer, genericProperty, formatterResolver); break; default: var formatter = formatterResolver.GetFormatter <object>(); formatter.Serialize(ref writer, value, formatterResolver); break; } }
public void Serialize(ref JsonWriter writer, ITokenizer value, IJsonFormatterResolver formatterResolver) { if (value == null) { writer.WriteNull(); return; } switch (value.Type) { case "char_group": Serialize <ICharGroupTokenizer>(ref writer, value, formatterResolver); break; case "edge_ngram": Serialize <IEdgeNGramTokenizer>(ref writer, value, formatterResolver); break; case "ngram": Serialize <INGramTokenizer>(ref writer, value, formatterResolver); break; case "path_hierarchy": Serialize <IPathHierarchyTokenizer>(ref writer, value, formatterResolver); break; case "pattern": Serialize <IPatternTokenizer>(ref writer, value, formatterResolver); break; case "standard": Serialize <IStandardTokenizer>(ref writer, value, formatterResolver); break; case "uax_url_email": Serialize <IUaxEmailUrlTokenizer>(ref writer, value, formatterResolver); break; case "whitespace": Serialize <IWhitespaceTokenizer>(ref writer, value, formatterResolver); break; case "kuromoji_tokenizer": Serialize <IKuromojiTokenizer>(ref writer, value, formatterResolver); break; case "icu_tokenizer": Serialize <IIcuTokenizer>(ref writer, value, formatterResolver); break; case "nori_tokenizer": Serialize <INoriTokenizer>(ref writer, value, formatterResolver); break; default: // serialize user defined tokenizer var formatter = formatterResolver.GetFormatter <object>(); formatter.Serialize(ref writer, value, formatterResolver); break; } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { IGeometry geom = value as IGeometry; if (geom == null) { writer.WriteNull(); return; } writer.WriteStartObject(); GeoJsonObjectType 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: IPolygon 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: IMultiPolygon mpoly = geom as IMultiPolygon; Debug.Assert(mpoly != null); var list = new List <List <Coordinate[]> >(); foreach (IPolygon mempoly in mpoly.Geometries) { list.Add(PolygonCoordinates(mempoly)); } if (serializer.NullValueHandling == NullValueHandling.Include || list.Count > 0) { writer.WritePropertyName("coordinates"); serializer.Serialize(writer, list); } break; case GeoJsonObjectType.GeometryCollection: IGeometryCollection gc = geom as IGeometryCollection; Debug.Assert(gc != null); serializer.Serialize(writer, gc.Geometries); break; default: List <Coordinate[]> coordinates = new List <Coordinate[]>(); foreach (IGeometry 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(); }
public void Serialize(ref JsonWriter writer, IPercentilesAggregation value, IJsonFormatterResolver formatterResolver) { if (value == null) { writer.WriteNull(); return; } writer.WriteBeginObject(); var propertyWritten = false; if (value.Meta != null && value.Meta.Any()) { writer.WritePropertyName("meta"); var formatter = formatterResolver.GetFormatter <IDictionary <string, object> >(); formatter.Serialize(ref writer, value.Meta, formatterResolver); propertyWritten = true; } if (value.Field != null) { if (propertyWritten) { writer.WriteValueSeparator(); } var settings = formatterResolver.GetConnectionSettings(); writer.WritePropertyName("field"); writer.WriteString(settings.Inferrer.Field(value.Field)); propertyWritten = true; } if (value.Script != null) { if (propertyWritten) { writer.WriteValueSeparator(); } writer.WritePropertyName("script"); var formatter = formatterResolver.GetFormatter <IScript>(); formatter.Serialize(ref writer, value.Script, formatterResolver); propertyWritten = true; } if (value.Method != null) { if (propertyWritten) { writer.WriteValueSeparator(); } switch (value.Method) { case ITDigestMethod tdigest: { writer.WritePropertyName("tdigest"); writer.WriteBeginObject(); if (tdigest.Compression.HasValue) { writer.WritePropertyName("compression"); writer.WriteDouble(tdigest.Compression.Value); } writer.WriteEndObject(); break; } case IHDRHistogramMethod hdr: { writer.WritePropertyName("hdr"); writer.WriteBeginObject(); if (hdr.NumberOfSignificantValueDigits.HasValue) { writer.WritePropertyName("number_of_significant_value_digits"); writer.WriteInt32(hdr.NumberOfSignificantValueDigits.Value); } writer.WriteEndObject(); break; } } propertyWritten = true; } if (value.Missing.HasValue) { if (propertyWritten) { writer.WriteValueSeparator(); } writer.WritePropertyName("missing"); writer.WriteDouble(value.Missing.Value); propertyWritten = true; } if (value.Percents != null) { if (propertyWritten) { writer.WriteValueSeparator(); } writer.WritePropertyName("percents"); var formatter = formatterResolver.GetFormatter <IEnumerable <double> >(); formatter.Serialize(ref writer, value.Percents, formatterResolver); propertyWritten = true; } if (value.Keyed.HasValue) { if (propertyWritten) { writer.WriteValueSeparator(); } writer.WritePropertyName("keyed"); writer.WriteBoolean(value.Keyed.Value); propertyWritten = true; } if (!string.IsNullOrEmpty(value.Format)) { if (propertyWritten) { writer.WriteValueSeparator(); } writer.WritePropertyName("format"); writer.WriteString(value.Format); } writer.WriteEndObject(); }
public void JsonReaderToJsonWriter(JsonReader reader, JsonWriter writer) { do { //log.Info("reader.TokenType-->" + reader.TokenType); switch (reader.TokenType) { case JsonToken.None: break; case JsonToken.StartObject: writer.WriteStartObject(); break; case JsonToken.StartArray: writer.WriteStartArray(); break; case JsonToken.PropertyName: writer.WritePropertyName(reader.Value.ToString()); break; case JsonToken.Comment: writer.WriteComment((reader.Value != null) ? reader.Value.ToString() : null); break; //数字/字符/布尔型/GUID都转成string case JsonToken.Integer: case JsonToken.Float: case JsonToken.String: case JsonToken.Boolean: case JsonToken.Bytes: writer.WriteValue(reader.Value.ToString()); break; case JsonToken.Null: if (this.PropertyNullValueReplaceValue != null) { writer.WriteValue(this.PropertyNullValueReplaceValue); } else { writer.WriteNull(); } break; case JsonToken.Undefined: writer.WriteUndefined(); break; case JsonToken.EndObject: writer.WriteEndObject(); break; case JsonToken.EndArray: writer.WriteEndArray(); break; case JsonToken.EndConstructor: writer.WriteEndConstructor(); break; case JsonToken.Date: if (reader.Value != null) { writer.WriteValue(((DateTime)reader.Value).ToString("yyyy-MM-dd HH:mm:ss")); } break; case JsonToken.Raw: writer.WriteRawValue((reader.Value != null) ? reader.Value.ToString() : null); break; } } while (reader.Read()); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { if (value is JsonLoggerOutput) { var output = value as JsonLoggerOutput; writer.WriteStartObject(); writer.WritePropertyName("successful"); writer.WriteValue(output.Succeeded); writer.WritePropertyName("stats"); writer.WriteStartObject(); foreach (var time in output.StepTimes) { writer.WritePropertyName(time.Key); writer.WriteValue(time.Value); } writer.WriteEndObject(); writer.WritePropertyName("messages"); writer.WriteStartArray(); foreach (var diagnostic in output.Diagnostics) { serializer.Serialize(writer, diagnostic); } writer.WriteEndArray(); writer.WriteEndObject(); } else if (value is Diagnostic) { var diagnostic = value as Diagnostic; writer.WriteStartObject(); writer.WritePropertyName("location"); if (diagnostic.Location != null) { writer.WriteStartObject(); writer.WritePropertyName("file"); writer.WriteValue(diagnostic.Location.FileName); writer.WritePropertyName("StartLine"); writer.WriteValue(diagnostic.Location.StartLine); writer.WritePropertyName("StartColumn"); writer.WriteValue(diagnostic.Location.StartColumn); writer.WritePropertyName("EndLine"); writer.WriteValue(diagnostic.Location.EndLine); writer.WritePropertyName("EndColumn"); writer.WriteValue(diagnostic.Location.EndColumn); writer.WriteEndObject(); } else { writer.WriteNull(); } writer.WritePropertyName("code"); writer.WriteValue(diagnostic.Code); writer.WritePropertyName("level"); writer.WriteValue(diagnostic.Level); writer.WritePropertyName("message"); writer.WriteValue(diagnostic.Message); writer.WriteEndObject(); } else { throw new InvalidOperationException(); } }
public override void WriteNull() { _textWriter.WriteNull(); _innerWriter.WriteNull(); base.WriteUndefined(); }
public void Serialize(ref JsonWriter writer, IGeoBoundingBoxQuery value, IJsonFormatterResolver formatterResolver) { if (value == null) { writer.WriteNull(); return; } var written = false; writer.WriteBeginObject(); if (!value.Name.IsNullOrEmpty()) { writer.WritePropertyName("_name"); writer.WriteString(value.Name); written = true; } if (value.Boost != null) { if (written) { writer.WriteValueSeparator(); } writer.WritePropertyName("boost"); writer.WriteDouble(value.Boost.Value); written = true; } if (value.ValidationMethod != null) { if (written) { writer.WriteValueSeparator(); } writer.WritePropertyName("validation_method"); formatterResolver.GetFormatter <GeoValidationMethod>() .Serialize(ref writer, value.ValidationMethod.Value, formatterResolver); written = true; } if (value.Type != null) { if (written) { writer.WriteValueSeparator(); } writer.WritePropertyName("type"); formatterResolver.GetFormatter <GeoExecution>() .Serialize(ref writer, value.Type.Value, formatterResolver); written = true; } if (written) { writer.WriteValueSeparator(); } var settings = formatterResolver.GetConnectionSettings(); writer.WritePropertyName(settings.Inferrer.Field(value.Field)); formatterResolver.GetFormatter <IBoundingBox>() .Serialize(ref writer, value.BoundingBox, formatterResolver); 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: { // 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 Serialize(ref JsonWriter writer, IProperty value, IJsonFormatterResolver formatterResolver) { if (value == null) { writer.WriteNull(); return; } switch (value.Type) { case "text": Serialize <ITextProperty>(ref writer, value, formatterResolver); break; case "keyword": Serialize <IKeywordProperty>(ref writer, value, formatterResolver); break; case "float": case "double": case "byte": case "short": case "integer": case "long": case "scaled_float": case "half_float": Serialize <INumberProperty>(ref writer, value, formatterResolver); break; case "date": Serialize <IDateProperty>(ref writer, value, formatterResolver); break; case "date_nanos": Serialize <IDateNanosProperty>(ref writer, value, formatterResolver); break; case "boolean": Serialize <IBooleanProperty>(ref writer, value, formatterResolver); break; case "binary": Serialize <IBinaryProperty>(ref writer, value, formatterResolver); break; case "object": Serialize <IObjectProperty>(ref writer, value, formatterResolver); break; case "nested": Serialize <INestedProperty>(ref writer, value, formatterResolver); break; case "ip": Serialize <IIpProperty>(ref writer, value, formatterResolver); break; case "geo_point": Serialize <IGeoPointProperty>(ref writer, value, formatterResolver); break; case "geo_shape": Serialize <IGeoShapeProperty>(ref writer, value, formatterResolver); break; case "completion": Serialize <ICompletionProperty>(ref writer, value, formatterResolver); break; case "token_count": Serialize <ITokenCountProperty>(ref writer, value, formatterResolver); break; case "murmur3": Serialize <IMurmur3HashProperty>(ref writer, value, formatterResolver); break; case "percolator": Serialize <IPercolatorProperty>(ref writer, value, formatterResolver); break; case "date_range": Serialize <IDateRangeProperty>(ref writer, value, formatterResolver); break; case "double_range": Serialize <IDoubleRangeProperty>(ref writer, value, formatterResolver); break; case "float_range": Serialize <IFloatRangeProperty>(ref writer, value, formatterResolver); break; case "integer_range": Serialize <IIntegerRangeProperty>(ref writer, value, formatterResolver); break; case "long_range": Serialize <ILongRangeProperty>(ref writer, value, formatterResolver); break; case "ip_range": Serialize <IIpRangeProperty>(ref writer, value, formatterResolver); break; case "join": Serialize <IJoinProperty>(ref writer, value, formatterResolver); break; case "alias": Serialize <IFieldAliasProperty>(ref writer, value, formatterResolver); break; case "rank_feature": Serialize <IRankFeatureProperty>(ref writer, value, formatterResolver); break; case "rank_features": Serialize <IRankFeaturesProperty>(ref writer, value, formatterResolver); break; default: if (value is IGenericProperty genericProperty) { Serialize <IGenericProperty>(ref writer, genericProperty, formatterResolver); } else { var formatter = DynamicObjectResolver.ExcludeNullCamelCase.GetFormatter <IProperty>(); formatter.Serialize(ref writer, value, formatterResolver); } break; } }
public void Serialize(ref JsonWriter writer, IGeoShapeQuery value, IJsonFormatterResolver formatterResolver) { var fieldName = value.Field; if (fieldName == null) { writer.WriteNull(); return; } var settings = formatterResolver.GetConnectionSettings(); var field = settings.Inferrer.Field(fieldName); if (field.IsNullOrEmpty()) { writer.WriteNull(); return; } writer.WriteBeginObject(); var name = value.Name; var boost = value.Boost; var ignoreUnmapped = value.IgnoreUnmapped; if (!name.IsNullOrEmpty()) { writer.WritePropertyName("_name"); writer.WriteString(name); writer.WriteValueSeparator(); } if (boost != null) { writer.WritePropertyName("boost"); writer.WriteDouble(boost.Value); writer.WriteValueSeparator(); } if (ignoreUnmapped != null) { writer.WritePropertyName("ignore_unmapped"); writer.WriteBoolean(ignoreUnmapped.Value); writer.WriteValueSeparator(); } writer.WritePropertyName(field); writer.WriteBeginObject(); var written = false; if (value.Shape != null) { writer.WritePropertyName("shape"); var shapeFormatter = formatterResolver.GetFormatter <IGeoShape>(); shapeFormatter.Serialize(ref writer, value.Shape, formatterResolver); written = true; } else if (value.IndexedShape != null) { writer.WritePropertyName("indexed_shape"); var fieldLookupFormatter = formatterResolver.GetFormatter <IFieldLookup>(); fieldLookupFormatter.Serialize(ref writer, value.IndexedShape, formatterResolver); written = true; } if (value.Relation.HasValue) { if (written) { writer.WriteValueSeparator(); } writer.WritePropertyName("relation"); formatterResolver.GetFormatter <GeoShapeRelation>() .Serialize(ref writer, value.Relation.Value, formatterResolver); } writer.WriteEndObject(); writer.WriteEndObject(); }
private void SerializeValue(JsonWriter writer, object value, JsonContract valueContract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty) { if (value == null) { writer.WriteNull(); return; } JsonConverter converter = ((member != null) ? member.Converter : null) ?? ((containerProperty != null) ? containerProperty.ItemConverter : null) ?? ((containerContract != null) ? containerContract.ItemConverter : null) ?? valueContract.Converter ?? Serializer.GetMatchingConverter(valueContract.UnderlyingType) ?? valueContract.InternalConverter; if (converter != null && converter.CanWrite) { SerializeConvertable(writer, converter, value, valueContract, containerContract, containerProperty); return; } switch (valueContract.ContractType) { case JsonContractType.Object: SerializeObject(writer, value, (JsonObjectContract)valueContract, member, containerContract, containerProperty); break; case JsonContractType.Array: JsonArrayContract arrayContract = (JsonArrayContract)valueContract; if (!arrayContract.IsMultidimensionalArray) { SerializeList(writer, (IEnumerable)value, arrayContract, member, containerContract, containerProperty); } else { SerializeMultidimensionalArray(writer, (Array)value, arrayContract, member, containerContract, containerProperty); } break; case JsonContractType.Primitive: SerializePrimitive(writer, value, (JsonPrimitiveContract)valueContract, member, containerContract, containerProperty); break; case JsonContractType.String: SerializeString(writer, value, (JsonStringContract)valueContract); break; case JsonContractType.Dictionary: JsonDictionaryContract dictionaryContract = (JsonDictionaryContract)valueContract; SerializeDictionary(writer, (value is IDictionary) ? (IDictionary)value : dictionaryContract.CreateWrapper(value), dictionaryContract, member, containerContract, containerProperty); break; #if !(NET35 || NET20 || PORTABLE40) case JsonContractType.Dynamic: SerializeDynamic(writer, (IDynamicMetaObjectProvider)value, (JsonDynamicContract)valueContract, member, containerContract, containerProperty); break; #endif #if !(DOTNET || PORTABLE40 || PORTABLE) case JsonContractType.Serializable: SerializeISerializable(writer, (ISerializable)value, (JsonISerializableContract)valueContract, member, containerContract, containerProperty); break; #endif case JsonContractType.Linq: ((JToken)value).WriteTo(writer, Serializer.Converters.ToArray()); break; } }
public void Serialize(ref JsonWriter writer, object value, IJsonFormatterResolver formatterResolver) { if (value == null) { writer.WriteNull(); return; } var t = value.GetType(); int key; if (typeToJumpCode.TryGetValue(t, out key)) { switch (key) { case 0: writer.WriteBoolean((bool)value); return; case 1: CharFormatter.Default.Serialize(ref writer, (char)value, formatterResolver); return; case 2: writer.WriteSByte((sbyte)value); return; case 3: writer.WriteByte((byte)value); return; case 4: writer.WriteInt16((Int16)value); return; case 5: writer.WriteUInt16((UInt16)value); return; case 6: writer.WriteInt32((int)value); return; case 7: writer.WriteUInt32((UInt32)value); return; case 8: writer.WriteInt64((long)value); return; case 9: writer.WriteUInt64((UInt64)value); return; case 10: writer.WriteSingle((float)value); return; case 11: writer.WriteDouble((double)value); return; case 12: ISO8601DateTimeFormatter.Default.Serialize(ref writer, (DateTime)value, formatterResolver); return; case 13: writer.WriteString((string)value); return; case 14: ByteArrayFormatter.Default.Serialize(ref writer, (byte[])value, formatterResolver); return; default: break; } } if (t.IsEnum) { writer.WriteString(t.ToString()); // enum as stringq return; } var dict = value as IDictionary; // check dictionary first if (dict != null) { var count = 0; writer.WriteBeginObject(); foreach (DictionaryEntry item in dict) { if (count++ != 0) { writer.WriteValueSeparator(); } writer.WritePropertyName((string)item.Key); Serialize(ref writer, item.Value, formatterResolver); } writer.WriteEndObject(); return; } var collection = value as ICollection; if (collection != null) { var count = 0; writer.WriteBeginArray(); foreach (var item in collection) { if (count++ != 0) { writer.WriteValueSeparator(); } Serialize(ref writer, item, formatterResolver); } writer.WriteEndArray(); return; } throw new InvalidOperationException("Not supported primitive object resolver. type:" + t.Name); }