/// <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)
{
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);
}
}
/// <summary>
/// Write this target to a JsonWriter
/// </summary>
/// <param name="Writer">Writer to output to</param>
void Write(JsonWriter Writer)
{
Writer.WriteObjectStart();
Writer.WriteValue("Name", Name);
Writer.WriteValue("LoadingPolicy", LoadingPolicy.ToString());
Writer.WriteObjectEnd();
}
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)
{
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();
}
/// <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] == '-')
{
// 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);
}
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
#if !(NETFX_CORE || DNXCORE50)
writer.WriteValue(":::" + value.ToString().ToUpper(CultureInfo.InvariantCulture) + ":::");
#else
writer.WriteValue(":::" + value.ToString().ToUpper() + ":::");
#endif
}
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 WriteJson(JsonWriter writer, Regex regex)
{
writer.WriteStartObject();
writer.WritePropertyName("Pattern");
writer.WriteValue(regex.ToString());
writer.WritePropertyName("Options");
writer.WriteValue(regex.Options);
writer.WriteEndObject();
}
public void WritesTwoPropertyArray()
{
var sw = new StringWriter();
var writer = new JsonWriter(sw);
writer.WriteStartArray();
writer.WriteValue(1);
writer.WriteValue(2);
writer.WriteEnd();
Assert.AreEqual("[1, 2]", sw.ToString());
}
public void TwoValuesAtRoot()
{
var sw = new StringWriter();
var writer = new JsonWriter(sw);
writer.WriteValue(1);
try {
writer.WriteValue(2);
Assert.Fail("Did not throw the expected exception");
} catch (NotSupportedException ex) {
Assert.AreEqual("Can not have two values at the root", ex.Message);
}
}
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");
}
}
public void WritesBooleanFalse()
{
var sw = new StringWriter();
var writer = new JsonWriter(sw);
writer.WriteValue(false);
Assert.AreEqual("false", 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)
{
long ticks;
if (value is DateTime)
{
DateTime dateTime = (DateTime)value;
DateTime utcDateTime = dateTime.ToUniversalTime();
ticks = JsonConvert.ConvertDateTimeToJavaScriptTicks(utcDateTime);
}
#if !PocketPC && !NET20
else if (value is DateTimeOffset)
{
DateTimeOffset dateTimeOffset = (DateTimeOffset)value;
DateTimeOffset utcDateTimeOffset = dateTimeOffset.ToUniversalTime();
ticks = JsonConvert.ConvertDateTimeToJavaScriptTicks(utcDateTimeOffset.UtcDateTime);
}
#endif
else
{
throw new JsonSerializationException("Expected date object value.");
}
writer.WriteStartConstructor("Date");
writer.WriteValue(ticks);
writer.WriteEndConstructor();
}
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();
}
public void WritesByte()
{
var sw = new StringWriter();
var writer = new JsonWriter(sw);
writer.WriteValue((Byte)123);
Assert.AreEqual("123", sw.ToString());
}
public void JsonWriter_EscapeCharacters()
{
var body = new Dictionary<string, object>();
body.Add("b", "\b");
body.Add("t", "\t");
body.Add("n", "\n");
body.Add("f", "\f");
body.Add("r", "\r");
body.Add("q", "\"");
body.Add("rs", "\\");
var sb = new StringBuilder();
using (var sw = new StringWriter(sb))
{
var jw = new JsonWriter(sw);
jw.WriteValue(body);
sw.Flush();
}
Assert.AreEqual("{" +
@"""b"":""\u0008""," +
@"""t"":""\u0009""," +
@"""n"":""\u000a""," +
@"""f"":""\u000c""," +
@"""r"":""\u000d""," +
@"""q"":""\""""," +
@"""rs"":""\\""" + "}",
sb.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)
{
long ticks;
if (value is DateTime)
{
var dateTime = (DateTime)value;
var utcDateTime = dateTime.ToUniversalTime();
ticks = DateTimeUtils.ConvertDateTimeToJavaScriptTicks(utcDateTime);
}
else if (value is DateTimeOffset)
{
var dateTimeOffset = (DateTimeOffset)value;
var utcDateTimeOffset = dateTimeOffset.ToUniversalTime();
ticks = DateTimeUtils.ConvertDateTimeToJavaScriptTicks(utcDateTimeOffset.UtcDateTime);
}
else
{
throw new JsonSerializationException("Expected date object value.");
}
writer.WriteStartConstructor("Date");
writer.WriteValue(ticks);
writer.WriteEndConstructor();
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) {
//long ticks;
/*if (value is DateTime) {
DateTime dateTime = (DateTime)value;
DateTime utcDateTime = dateTime.ToUniversalTime();
ticks = JsonConvert.ConvertDateTimeToJavaScriptTicks(utcDateTime);
} else if (value is DateTimeOffset) {
DateTimeOffset dateTimeOffset = (DateTimeOffset)value;
DateTimeOffset utcDateTimeOffset = dateTimeOffset.ToUniversalTime();
ticks = JsonConvert.ConvertDateTimeToJavaScriptTicks(utcDateTimeOffset.UtcDateTime);
} else {
throw new Exception("Expected date object value.");
}*/
//writer.WriteStartConstructor("Date");
//writer.WriteValue(ticks);
//writer.WriteEndConstructor();
if (value is DateTime) {
DateTime dateTime = (DateTime)value;
DateTime vLocValue = DateTime.SpecifyKind(dateTime, DateTimeKind.Utc);
writer.WriteValue(vLocValue);
} else {
throw new Exception("Expected date object value.");
}
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var converter = GetConverter(value.GetType());
var text = converter.ConvertToInvariantString(value);
writer.WriteValue(text);
}
public void WritesEscapedQuoteString()
{
var sw = new StringWriter();
var writer = new JsonWriter(sw);
writer.WriteValue("this is escaped: \"");
Assert.AreEqual("\"this is escaped: \\\"\"", sw.ToString());
}
public void WritesNonEscapedString()
{
var sw = new StringWriter();
var writer = new JsonWriter(sw);
writer.WriteValue("hello, world");
Assert.AreEqual("\"hello, world\"", sw.ToString());
}
public void WritesEscapedUnicodeCharacters()
{
var sw = new StringWriter();
var writer = new JsonWriter(sw);
writer.WriteValue("this is escaped: \u3034");
Assert.AreEqual("\"this is escaped: \\u3034\"", sw.ToString());
}
public void WritesEscapedControlCharacters()
{
var sw = new StringWriter();
var writer = new JsonWriter(sw);
writer.WriteValue("this is escaped: \b\f\n\r\t\x17");
Assert.AreEqual("\"this is escaped: \\b\\f\\n\\r\\t\\x17\"", 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)
{
string text;
if (value is DateTime)
{
DateTime dateTime = (DateTime)value;
if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal
|| (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal)
dateTime = dateTime.ToUniversalTime();
text = dateTime.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture);
}
else if (value is DateTimeOffset)
{
DateTimeOffset dateTimeOffset = (DateTimeOffset)value;
if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal
|| (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal)
dateTimeOffset = dateTimeOffset.ToUniversalTime();
text = dateTimeOffset.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture);
}
else
{
throw new Exception("Unexpected value when converting date. Expected DateTime or DateTimeOffset, got {0}.".FormatWith(CultureInfo.InvariantCulture, ReflectionUtils.GetObjectType(value)));
}
writer.WriteValue(text);
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
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)
{
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] == '-')
writer.WriteValue(value);
else
writer.WriteValue(enumName);
}
public override void WriteJson(JsonWriter writer, object value)
{
DateTime dateTime = (DateTime)value;
long javaScriptTicks = JavaScriptConvert.ConvertDateTimeToJavaScriptTicks(dateTime);
writer.WriteValue("@" + javaScriptTicks.ToString(null, CultureInfo.InvariantCulture) + "@");
}
public override void WriteJson(JsonWriter writer, RebootSource value, JsonSerializer serializer)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
writer?.WriteValue(value.Value);
}
public override void WriteJson(JsonWriter?writer, object?value, JsonSerializer serializer)
{
if (value is null)
{
return;
}
writer?.WriteValue(((Date)value).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)
{
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));
return;
case JTokenType.Float:
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)
{
writer.WriteValue(HttpUtility.HtmlEncode(value.ToString()));
}
/// <summary>
/// Write a well-known binary object to JSON.
/// </summary>
/// <param name="lebr">
/// The little-endian binary reader.
/// </param>
/// <param name="bebr">
/// The big-endian binary reader.
/// </param>
/// <param name="writer">
/// The writer.
/// </param>
/// <exception cref="ArgumentException">
/// Unexpected well-known binary.
/// </exception>
private static void WriteObject(BinaryReader lebr, BinaryReader bebr, JsonWriter writer)
{
writer.WriteStartObject();
writer.WritePropertyName("type");
var br = lebr.ReadByte() == 0 ? bebr : lebr;
int gtype = br.ReadInt32();
string objTypeName;
if (!WkbTypes.TryGetValue(gtype, out objTypeName))
{
throw new ArgumentException(
string.Format(
"Unsupported type {0}. Supported types: {1}",
gtype,
string.Join(", ", WkbTypes.Select(kv => string.Format("({0}, {1}", kv.Key, kv.Value)))));
}
writer.WriteValue(objTypeName);
if (gtype == GeometryCollectionWkb)
{
writer.WritePropertyName("geometries");
writer.WriteStartArray();
int count = br.ReadInt32();
for (int i = 0; i < count; ++i)
{
WriteObject(lebr, bebr, writer);
}
writer.WriteEndArray();
}
else
{
writer.WritePropertyName("coordinates");
writer.WriteStartArray();
switch (gtype)
{
case PointWkb:
writer.WriteValue(br.ReadDouble());
writer.WriteValue(br.ReadDouble());
break;
case LineStringWkb:
WriteLine(br, writer);
break;
case PolygonWkb:
WritePolygon(br, writer);
break;
case MultiPointWkb:
int pointCount = br.ReadInt32();
for (int i = 0; i < pointCount; ++i)
{
br = lebr.ReadByte() == 0 ? bebr : lebr;
gtype = br.ReadInt32();
if (gtype != PointWkb)
{
throw new ArgumentException(
string.Format("Expected a type of 1, got {0}", gtype),
"lebr");
}
writer.WriteStartArray();
writer.WriteValue(br.ReadDouble());
writer.WriteValue(br.ReadDouble());
writer.WriteEndArray();
}
break;
case MultiLineStringWkb:
int lineCount = br.ReadInt32();
for (int i = 0; i < lineCount; ++i)
{
br = lebr.ReadByte() == 0 ? bebr : lebr;
gtype = br.ReadInt32();
if (gtype != LineStringWkb)
{
throw new ArgumentException(
string.Format("Expected a type of 2, got {0}", gtype),
"lebr");
}
writer.WriteStartArray();
WriteLine(br, writer);
writer.WriteEndArray();
}
break;
case MultiPolygonWkb:
int polygonCount = br.ReadInt32();
for (int i = 0; i < polygonCount; ++i)
{
br = lebr.ReadByte() == 0 ? bebr : lebr;
gtype = br.ReadInt32();
if (gtype != PolygonWkb)
{
throw new ArgumentException(
string.Format("Expected a type of 3, got {0}", gtype),
"lebr");
}
writer.WriteStartArray();
WritePolygon(br, writer);
writer.WriteEndArray();
}
break;
default:
throw new ArgumentException(string.Format("Unsupported geo-type {0}", gtype), "lebr");
}
writer.WriteEndArray();
}
writer.WriteEndObject();
}
public override void WriteJson(JsonWriter writer, Color value, JsonSerializer serializer)
{
writer.WriteValue(ColorTranslator.ToHtml(value) + value.A.ToString("X2"));
}
public void WriteBoolean(bool value)
{
_jsonWriter.WriteValue(value);
}
/// <inheritdoc />
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
writer.WriteValue(((uint256)value).ToString());
}
public override void WriteJson(JsonWriter writer, TimeSpan value, JsonSerializer serializer)
{
var timespanFormatted = $"{value.ToString(TimeSpanFormatString)}";
writer.WriteValue(timespanFormatted);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
writer.WriteValue(((StringEnum)value).Value);
}
public override void WriteJson(JsonWriter writer, TNull value, JsonSerializer serializer) => writer?.WriteValue(Format(value));
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var vector = (Vector3)value;
writer.WriteValue($"{vector.x} {vector.y} {vector.z}");
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) => writer.WriteValue((bool)value ? 1 : 0);
/// <summary>
/// 写json格式的时间
/// </summary>
/// <param name="writer"></param>
/// <param name="value"></param>
/// <param name="serializer"></param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
writer.WriteValue(ConvertDateTimeInt((DateTime)value));
}
public void Execute(IEnumerable <DataRow> rows, ISampler <DataRow> sampler, IEnumerable <ColumnMetadata> metadata, JsonWriter writer)
{
rows = rows ?? new List <DataRow>();
sampler.Build(rows);
var sampled = sampler.GetResult();
writer.WriteStartObject();
writer.WritePropertyName("total-rows");
writer.WriteValue(rows.Count());
if (sampler.GetIsSampled())
{
writer.WritePropertyName("sampled-rows");
writer.WriteValue(rows.Count() - sampler.GetExcludedRowCount());
}
if (sampled.Count() > 0)
{
writer.WritePropertyName("table");
writer.WriteStartObject();
writer.WritePropertyName("columns");
writer.WriteStartArray();
var formatters = new List <IPresenter>();
var columns = sampled.ElementAt(0).Table.Columns;
for (var i = 0; i < columns.Count; i++)
{
var meta = metadata.ElementAt(i);
writer.WriteStartObject();
writer.WritePropertyName("position");
writer.WriteValue(columns[i].Ordinal);
writer.WritePropertyName("name");
writer.WriteValue(columns[i].ColumnName);
var cpFormatter = new ColumnPropertiesFormatter();
writer.WritePropertyName("role");
writer.WriteValue(cpFormatter.GetRoleText(meta.Role));
writer.WritePropertyName("type");
writer.WriteValue(cpFormatter.GetTypeText(meta.Type));
if (!Tolerance.IsNullOrNone(meta.Tolerance))
{
writer.WritePropertyName("tolerance");
writer.WriteValue(cpFormatter.GetToleranceText(meta.Tolerance).Trim());
}
if (meta.Rounding != null)
{
writer.WritePropertyName("rounding");
writer.WriteValue(cpFormatter.GetRoundingText(meta.Rounding));
}
formatters.Add(new PresenterFactory().Instantiate(metadata.ElementAt(i).Type));
writer.WriteEndObject();
}
writer.WriteEndArray(); //columns
BuildRows(sampled, formatters, writer);
writer.WriteEndObject(); //table
}
writer.WriteEndObject();
}
/// <inheritdoc /> public override void WriteJson(JsonWriter writer, Author value, JsonSerializer serializer) => writer?.WriteValue(value.ToString());
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var postedOn = (DateTime)value;
writer.WriteValue(postedOn.Ticks.ToString());
}
public override void WriteJson(JsonWriter writer, UDecimal value, JsonSerializer serializer)
{
writer?.WriteValue((decimal)value);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
writer.WriteValue(value);
}
public override void WriteTo(JsonWriter writer, params JsonConverter[] converters)
{
if (converters != null && converters.Length > 0 && this._value != null)
{
JsonConverter matchingConverter = JsonSerializer.GetMatchingConverter((IList<JsonConverter>) converters, this._value.GetType());
if (matchingConverter != null)
{
matchingConverter.WriteJson(writer, this._value, new JsonSerializer());
return;
}
}
switch (this._valueType)
{
case JTokenType.Comment:
writer.WriteComment(this._value != null ? this._value.ToString() : (string) null);
break;
case JTokenType.Integer:
writer.WriteValue(Convert.ToInt64(this._value, (IFormatProvider) CultureInfo.InvariantCulture));
break;
case JTokenType.Float:
if (this._value is Decimal)
{
writer.WriteValue((Decimal) this._value);
break;
}
else if (this._value is double)
{
writer.WriteValue((double) this._value);
break;
}
else if (this._value is float)
{
writer.WriteValue((float) this._value);
break;
}
else
{
writer.WriteValue(Convert.ToDouble(this._value, (IFormatProvider) CultureInfo.InvariantCulture));
break;
}
case JTokenType.String:
writer.WriteValue(this._value != null ? this._value.ToString() : (string) null);
break;
case JTokenType.Boolean:
writer.WriteValue(Convert.ToBoolean(this._value, (IFormatProvider) CultureInfo.InvariantCulture));
break;
case JTokenType.Null:
writer.WriteNull();
break;
case JTokenType.Undefined:
writer.WriteUndefined();
break;
case JTokenType.Date:
writer.WriteValue(Convert.ToDateTime(this._value, (IFormatProvider) CultureInfo.InvariantCulture));
break;
case JTokenType.Raw:
writer.WriteRawValue(this._value != null ? this._value.ToString() : (string) null);
break;
case JTokenType.Bytes:
writer.WriteValue((byte[]) this._value);
break;
case JTokenType.Guid:
case JTokenType.Uri:
case JTokenType.TimeSpan:
writer.WriteValue(this._value != null ? this._value.ToString() : (string) null);
break;
default:
throw MiscellaneousUtils.CreateArgumentOutOfRangeException("TokenType", (object) this._valueType, "Unexpected token type.");
}
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
string valueString = value.ToString();
writer.WriteValue(valueString);
}
private void WriteTypeProperty(JsonWriter writer, Type type)
{
writer.WritePropertyName(JsonTypeReflector.TypePropertyName);
writer.WriteValue(ReflectionUtils.GetTypeName(type, Serializer.TypeNameAssemblyFormat, Serializer.Binder));
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
writer.WriteValue(DateTimeConverter.DateToString((DateTime)value));
}
public override void WriteJson(JsonWriter writer, UDouble value, JsonSerializer serializer)
{
writer?.WriteValue(value);
}
public override void WriteJson(JsonWriter writer, Range value, JsonSerializer serializer) => writer.WriteValue(value.ToString());
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
writer.WriteValue(((double)value).InAcres());
}
/// <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)
{
writer.WriteValue(ColorTranslator.ToHtml((Color)value));
}
public override void WriteJson(JsonWriter writer, KzUInt512 value, JsonSerializer serializer)
{
writer.WriteValue(value.ToString());
}
public void WriteJson(JsonWriter writer, JsonSerializer serializer)
{
writer.WriteValue(Value);
}
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);
}
}
