public void Example()
{
#region Usage
JTokenWriter writer = new JTokenWriter();
writer.WriteStartObject();
writer.WritePropertyName("name1");
writer.WriteValue("value1");
writer.WritePropertyName("name2");
writer.WriteStartArray();
writer.WriteValue(1);
writer.WriteValue(2);
writer.WriteEndArray();
writer.WriteEndObject();
JObject o = (JObject)writer.Token;
Console.WriteLine(o.ToString());
// {
// "name1": "value1",
// "name2": [
// 1,
// 2
// ]
// }
#endregion
}
public void ValueFormatting()
{
byte[] data = Encoding.UTF8.GetBytes("Hello world.");
JToken root;
using (JTokenWriter jsonWriter = new JTokenWriter())
{
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((string)null);
jsonWriter.WriteValue("This is a string.");
jsonWriter.WriteNull();
jsonWriter.WriteUndefined();
jsonWriter.WriteValue(data);
jsonWriter.WriteEndArray();
root = jsonWriter.Token;
}
Assert.IsType(typeof(JArray), root);
Assert.Equal(13, root.Children().Count());
Assert.Equal("@", (string)root[0]);
Assert.Equal("\r\n\t\f\b?{\\r\\n\"\'", (string)root[1]);
Assert.Equal(true, (bool)root[2]);
Assert.Equal(10, (int)root[3]);
Assert.Equal(10.99, (double)root[4]);
Assert.Equal(0.99, (double)root[5]);
Assert.Equal(0.000000000000000001d, (double)root[6]);
Assert.Equal(0.000000000000000001m, (decimal)root[7]);
Assert.Equal(null, (string)root[8]);
Assert.Equal("This is a string.", (string)root[9]);
Assert.Equal(null, ((JValue)root[10]).Value);
Assert.Equal(null, ((JValue)root[11]).Value);
Assert.Equal(data, (byte[])root[12]);
}
private JToken CreateJObject (JsonReader reader)
{
ValidationUtils.ArgumentNotNull(reader, "reader");
// this is needed because we've already read inside the object, looking for metadata properties
using (JTokenWriter writer = new JTokenWriter()) {
writer.WriteStartObject();
do {
if (reader.TokenType == JsonToken.PropertyName) {
string propertyName = (string)reader.Value;
do {
if (!reader.Read())
break;
} while (reader.TokenType == JsonToken.Comment);
if (CheckPropertyName(reader, propertyName))
continue;
writer.WritePropertyName(propertyName);
writer.WriteToken(reader, true, true);
}
else if (reader.TokenType == JsonToken.Comment) {
// eat
}
else {
writer.WriteEndObject();
return writer.Token;
}
} while (reader.Read());
throw JsonSerializationException.Create(reader, "Unexpected end when deserializing object.");
}
}
private JToken CreateJToken (JsonReader reader, JsonContract contract)
{
ValidationUtils.ArgumentNotNull(reader, "reader");
if (contract != null) {
if (contract.UnderlyingType == typeof(JRaw))
return JRaw.Create(reader);
if (reader.TokenType == JsonToken.Null
&& !(contract.UnderlyingType == typeof(JValue) || contract.UnderlyingType == typeof(JToken)))
return null;
}
JToken token;
using (JTokenWriter writer = new JTokenWriter()) {
writer.WriteToken(reader);
token = writer.Token;
}
return token;
}
public void JTokenWriter()
{
JsonIgnoreAttributeOnClassTestClass ignoreAttributeOnClassTestClass = new JsonIgnoreAttributeOnClassTestClass();
ignoreAttributeOnClassTestClass.Field = int.MinValue;
JsonSerializer serializer = new JsonSerializer();
serializer.ContractResolver = new CamelCasePropertyNamesContractResolver();
JTokenWriter writer = new JTokenWriter();
serializer.Serialize(writer, ignoreAttributeOnClassTestClass);
JObject o = (JObject)writer.Token;
JProperty p = o.Property("theField");
Assert.NotNull(p);
Assert.Equal(int.MinValue, (int)p.Value);
string json = o.ToString();
}
public void DateTimeZoneHandling()
{
JTokenWriter writer = new JTokenWriter
{
DateTimeZoneHandling = Json.DateTimeZoneHandling.Utc
};
writer.WriteValue(new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Unspecified));
JValue value = (JValue)writer.Token;
DateTime dt = (DateTime)value.Value;
Assert.Equal(new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Utc), dt);
}
public void WriteRaw()
{
JTokenWriter writer = new JTokenWriter();
writer.WriteStartArray();
writer.WriteRaw("fail");
writer.WriteRaw("fail");
writer.WriteEndArray();
// this is a bug. write raw shouldn't be autocompleting like this
// hard to fix without introducing Raw and RawValue token types
// meh
StringAssert.Equal(@"[
fail,
fail
]", writer.Token.ToString());
}
public void WriteRawValue()
{
JTokenWriter writer = new JTokenWriter();
writer.WriteStartArray();
writer.WriteRawValue("fail");
writer.WriteRawValue("fail");
writer.WriteEndArray();
StringAssert.Equal(@"[
fail,
fail
]", writer.Token.ToString());
}
public void WriteComment()
{
JTokenWriter writer = new JTokenWriter();
writer.WriteStartArray();
writer.WriteComment("fail");
writer.WriteEndArray();
StringAssert.Equal(@"[
/*fail*/]", writer.Token.ToString());
}
public void WriteBigInteger()
{
JTokenWriter writer = new JTokenWriter();
writer.WriteStartArray();
writer.WriteValue(new BigInteger(123));
writer.WriteEndArray();
JValue i = (JValue)writer.Token[0];
Assert.Equal(new BigInteger(123), i.Value);
Assert.Equal(JTokenType.Integer, i.Type);
StringAssert.Equal(@"[
123
]", writer.Token.ToString());
}
public void State()
{
using (JsonWriter jsonWriter = new JTokenWriter())
{
Assert.Equal(WriteState.Start, jsonWriter.WriteState);
jsonWriter.WriteStartObject();
Assert.Equal(WriteState.Object, jsonWriter.WriteState);
jsonWriter.WritePropertyName("CPU");
Assert.Equal(WriteState.Property, jsonWriter.WriteState);
jsonWriter.WriteValue("Intel");
Assert.Equal(WriteState.Object, jsonWriter.WriteState);
jsonWriter.WritePropertyName("Drives");
Assert.Equal(WriteState.Property, jsonWriter.WriteState);
jsonWriter.WriteStartArray();
Assert.Equal(WriteState.Array, jsonWriter.WriteState);
jsonWriter.WriteValue("DVD read/writer");
Assert.Equal(WriteState.Array, jsonWriter.WriteState);
#if NET40
jsonWriter.WriteValue(new BigInteger(123));
Assert.Equal(WriteState.Array, jsonWriter.WriteState);
#endif
jsonWriter.WriteValue(new byte[0]);
Assert.Equal(WriteState.Array, jsonWriter.WriteState);
jsonWriter.WriteEnd();
Assert.Equal(WriteState.Object, jsonWriter.WriteState);
jsonWriter.WriteEndObject();
Assert.Equal(WriteState.Start, jsonWriter.WriteState);
}
}
public void DateTimeOffset()
{
List<DateTimeOffset> testDates = new List<DateTimeOffset>
{
new DateTimeOffset(new DateTime(100, 1, 1, 1, 1, 1, DateTimeKind.Utc)),
new DateTimeOffset(2000, 1, 1, 1, 1, 1, TimeSpan.Zero),
new DateTimeOffset(2000, 1, 1, 1, 1, 1, TimeSpan.FromHours(13)),
new DateTimeOffset(2000, 1, 1, 1, 1, 1, TimeSpan.FromHours(-3.5)),
};
JsonSerializer jsonSerializer = new JsonSerializer();
JTokenWriter jsonWriter;
using (jsonWriter = new JTokenWriter())
{
jsonSerializer.Serialize(jsonWriter, testDates);
}
Assert.Equal(4, jsonWriter.Token.Children().Count());
}
private static string SerializeWithNoRedundentIdProperties(object o)
{
JTokenWriter writer = new JTokenWriter();
JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings
{
Formatting = Formatting.Indented,
PreserveReferencesHandling = PreserveReferencesHandling.Objects
});
serializer.Serialize(writer, o);
JToken t = writer.Token;
if (t is JContainer)
{
JContainer c = t as JContainer;
// find all the $id properties in the JSON
IList<JProperty> ids = c.Descendants().OfType<JProperty>().Where(d => d.Name == "$id").ToList();
if (ids.Count > 0)
{
// find all the $ref properties in the JSON
IList<JProperty> refs = c.Descendants().OfType<JProperty>().Where(d => d.Name == "$ref").ToList();
foreach (JProperty idProperty in ids)
{
// check whether the $id property is used by a $ref
bool idUsed = refs.Any(r => idProperty.Value.ToString() == r.Value.ToString());
if (!idUsed)
{
// remove unused $id
idProperty.Remove();
}
}
}
}
string json = t.ToString();
return json;
}
public void RoundTripDecimal()
{
var jTokenWriter = new JTokenWriter();
new JsonSerializer().Serialize(jTokenWriter, rate);
var rate2 = new JsonSerializer().Deserialize<Rate>(new JTokenReader(jTokenWriter.Token));
Assert.Equal(rate.Compoundings, rate2.Compoundings);
}
public void WriteFullDecimalPrecision()
{
var jTokenWriter = new JTokenWriter();
new JsonSerializer().Serialize(jTokenWriter, rate);
string json = jTokenWriter.Token.ToString();
StringAssert.Equal(@"{
""Compoundings"": 12.166666666666666666666666667
}", json);
}
