internal static void WriteValue(Type value, JsonSerializerHandler handler)
{
if (value == null)
{
handler.Writer.Append("null");
}
else
{
PrimitiveNormal.WriteValue(value.AssemblyQualifiedName, handler);
}
}
internal static void WriteDynamic(object value, JsonSerializerHandler handler)
{
if (value == null)
{
handler.Writer.Append("null");
return;
}
if (handler.Option.ReferenceLoopHandling != JsonReferenceHandlingEnum.None)
{
if (handler.SerializeStacks.Contains(value))
{
if (handler.Option.ReferenceLoopHandling == JsonReferenceHandlingEnum.Null)
{
handler.Writer.Append("null");
}
else if (handler.Option.ReferenceLoopHandling == JsonReferenceHandlingEnum.Empty)
{
handler.Writer.Append("{}");
}
else if (handler.Option.ReferenceLoopHandling == JsonReferenceHandlingEnum.Remove)
{
RemoveWriterHelper.RemoveDictionaryKey(handler.Writer);
}
return;
}
handler.SerializeStacks.Push(value);
}
var t = value.GetType();
handler.Writer.Append("{");
bool isFirst = true;
foreach (var item in t.GetProperties())
{
if (isFirst)
{
isFirst = false;
}
else
{
handler.Writer.Append(",");
}
handler.Writer.Append("\"");
handler.Writer.Append(item.Name);
handler.Writer.Append("\"");
handler.Writer.Append(":");
SerializerObjectJump.GetThreadSafetyJumpAction(item.PropertyType)(item.GetValue(value), handler);
}
handler.Writer.Append("}");
}
internal static void WriteEnum(Enum value, JsonSerializerHandler handler)
{
if (handler.Option.IsEnumNum)
{
PrimitiveNormal.WriteValue(value.GetHashCode(), handler);
}
else
{
handler.Writer.Append("\"");
handler.Writer.Append(value.ToString());
handler.Writer.Append("\"");
}
}
internal static void RemoveKeyAndAddIndex(JsonSerializerHandler handler, Stack <int> commaIndexs)
{
if (handler.stringBuilder != null)
{
StringBuilder sb = handler.stringBuilder;
if (sb.Length < 3)
{
return;
}
int startIndex = 0;
int leng = -1;
for (int i = sb.Length - 2 - 1; i >= 0; i--)
{
if (sb[i] == '"')
{
startIndex = i;
leng = sb.Length - i;
sb.Remove(startIndex, leng);
commaIndexs.Push(sb.Length - 1);
return;
}
}
}
else
{
int length = StreamOperate.GetStreamWriterCharLen(handler.streamWriter);
if (length < 3)
{
return;
}
int startIndex = 0;
char[] buf = StreamOperate.GetStreamWriterCharBuffer(handler.streamWriter);
int leng = -1;
for (int i = length - 2 - 1; i >= 0; i--)
{
if (buf[i] == '"')
{
startIndex = i;
leng = length - i;
handler.streamWriter.Remove(startIndex, leng);
commaIndexs.Push(length - leng - 1);
return;
}
}
}
}
public override string WriteValueFormat(object value, Type type, JsonSerializerHandler handler, out bool isValueFormat)
{
isValueFormat = true;
if (value == null)
{
return(null);
}
else if (value is Version)
{
return(value.ToString());
}
else
{
throw new Exception("Expected Version object value");
}
}
internal static void WriteValue(DataTable value, JsonSerializerHandler handler)
{
if (value == null)
{
handler.Writer.Append("null");
return;
}
handler.Writer.Append("[");
bool isFirst = true;
foreach (DataRow row in value.Rows)
{
if (isFirst)
{
isFirst = false;
}
else
{
handler.Writer.Append(",");
}
handler.Writer.Append("{");
bool isFirst2 = true;
foreach (DataColumn column in row.Table.Columns)
{
if (isFirst2)
{
isFirst2 = false;
}
else
{
handler.Writer.Append(",");
}
object columnValue = row[column];
handler.Writer.Append("\"");
handler.Writer.Append(column.ColumnName);//没有检查
handler.Writer.Append("\":");
PrimitiveNormal.WriteValue(columnValue, handler);
}
handler.Writer.Append("}");
}
handler.Writer.Append("]");
}
internal static void WriteValue(int value, JsonSerializerHandler handler)
{
// Gotta special case this, we can't negate it
if (value == int.MinValue)
{
handler.Writer.Append("-2147483648");
return;
}
if (value == int.MaxValue)
{
handler.Writer.Append("2147483647");
return;
}
var ptr = 35;
char[] buffer = new char[36];
uint copy;
if (value < 0)
{
handler.Writer.Append('-');
copy = (uint)(-value);
}
else
{
copy = (uint)value;
}
do
{
byte ix = (byte)(copy % 100);
copy /= 100;
var chars = SpecialTypeNormal.DigitPairs[ix];
buffer[ptr--] = chars.Second;
buffer[ptr--] = chars.First;
} while (copy != 0);
if (buffer[ptr + 1] == '0')
{
ptr++;
}
handler.Writer.Append(buffer, ptr + 1, 35 - ptr);
}
internal static void WriteValue(double value, JsonSerializerHandler handler)
{
switch (value)
{
case double.NaN:
handler.Writer.Append("\"NaN\"");
return;
case double.NegativeInfinity:
handler.Writer.Append("\"-Infinity\"");
return;
case double.PositiveInfinity:
handler.Writer.Append("\"Infinity\"");
return;
}
handler.Writer.Append(value.ToString("R", CultureInfo.InvariantCulture));
}
internal static void WriteIEnumerable(IEnumerable value, JsonSerializerHandler handler)
{
if (handler.Option.ReferenceLoopHandling != JsonReferenceHandlingEnum.None)
{
if (handler.SerializeStacks.Contains(value))
{
if (handler.Option.ReferenceLoopHandling == JsonReferenceHandlingEnum.Null)
{
handler.Writer.Append("null");
}
else if (handler.Option.ReferenceLoopHandling == JsonReferenceHandlingEnum.Empty)
{
handler.Writer.Append("[]");
}
else if (handler.Option.ReferenceLoopHandling == JsonReferenceHandlingEnum.Remove)
{
RemoveWriterHelper.RemoveArrayItem(handler.Writer);
}
return;
}
handler.SerializeStacks.Push(value);
}
handler.Writer.Append("[");
bool isFirst = true;
foreach (var obj in value)
{
if (isFirst)
{
isFirst = false;
}
else
{
handler.Writer.Append(",");
}
PrimitiveNormal.WriteValue(obj, handler);
}
handler.Writer.Append("]");
if (handler.Option.ReferenceLoopHandling != JsonReferenceHandlingEnum.None)
{
handler.SerializeStacks.Pop();
}
}
internal static void WriteDictionary(IDictionary value, JsonSerializerHandler handler)
{
if (value == null)
{
handler.Writer.Append("null");
return;
}
var t = value.GetType();
if (t.IsGenericType)
{
var serializerAction = SerializerObjectJump.GetThreadSafetyJumpAction(t);
serializerAction(value, handler);
}
else
{
WriteIDictionary(value, handler);
}
}
internal static void RemoveArrayItem(JsonSerializerHandler handler)
{
if (handler.stringBuilder != null)
{
if (handler.stringBuilder.Length <= 1)
{
return;
}
if (handler.stringBuilder[handler.stringBuilder.Length - 1] == '[')
{
return;
}
if (handler.stringBuilder[handler.stringBuilder.Length - 1] == ':')
{
RemoveDictionaryKey(handler);
}
else
{
handler.stringBuilder.Remove(handler.stringBuilder.Length - 1, 1);
}
}
else
{
int length = StreamOperate.GetStreamWriterCharLen(handler.streamWriter);
if (length <= 1)
{
return;
}
char[] buf = StreamOperate.GetStreamWriterCharBuffer(handler.streamWriter);
if (buf[length - 1] == '[')
{
return;
}
if (buf[length - 1] == ':')
{
RemoveDictionaryKey(handler);
}
else
{
handler.streamWriter.Remove(length - 1, 1);
}
}
}
internal static void WriteValue(Exception value, JsonSerializerHandler handler)
{
if (value == null)
{
handler.WriteString("null");
}
else
{
handler.WriteString("{\"Message\":");
PrimitiveNormal.WriteValue(value.Message, handler);
handler.WriteString(",\"Source\":");
PrimitiveNormal.WriteValue(value.Source, handler);
handler.WriteString(",\"StackTrace\":");
PrimitiveNormal.WriteValue(value.StackTrace, handler);
handler.WriteString(",\"HelpLink\":");
PrimitiveNormal.WriteValue(value.HelpLink, handler);
handler.WriteString("}");
}
}
internal static void WriteValue(object obj, JsonSerializerHandler handler)
{
if (obj == null)
{
handler.Writer.Append("null");
return;
}
var type = obj.GetType();
if (type.IsAnonymousType() || type == typeof(object))
{
SpecialConditions.WriteDynamic(obj, handler);
}
else
{
var jumpAction = SerializerObjectJump.GetThreadSafetyJumpAction(type);
jumpAction(obj, handler);
}
}
internal static void DeleteComma(JsonSerializerHandler handler, Stack <int> lists)
{
if (handler.stringBuilder != null)
{
StringBuilder sb = handler.stringBuilder;
if (lists.Count > 0)
{
RemoveLastComma(handler);
var lastCommaIndex = lists.Peek();
if (lastCommaIndex >= sb.Length - 1)
{
lists.Pop();
}
}
while (lists.Count > 0)
{
var index = lists.Pop();
sb.Remove(index + 1, 1);
}
}
else
{
if (lists.Count > 0)
{
RemoveLastComma(handler);
var lastCommaIndex = lists.Peek();
if (lastCommaIndex >= StreamOperate.GetStreamWriterCharLen(handler.streamWriter) - 1)
{
lists.Pop();
}
}
while (lists.Count > 0)
{
var index = lists.Pop();
handler.streamWriter.Remove(index + 1, 1);
}
}
}
internal static void RemoveLastComma(JsonSerializerHandler handler)
{
if (handler.stringBuilder != null)
{
StringBuilder sb = handler.stringBuilder;
if (sb[sb.Length - 1] == ',')
{
sb.Remove(sb.Length - 1, 1);
}
}
else
{
int length = StreamOperate.GetStreamWriterCharLen(handler.streamWriter);
char[] buf = StreamOperate.GetStreamWriterCharBuffer(handler.streamWriter);
if (buf[length - 1] == ',')
{
handler.streamWriter.Remove(length - 1, 1);
}
}
}
internal static void WriteValue(long value, JsonSerializerHandler handler)
{
if (value == long.MinValue)
{
handler.Writer.Append("-9223372036854775808");
return;
}
char[] buffer = new char[36];
var ptr = 35;
ulong copy;
if (value < 0)
{
handler.Writer.Append('-');
copy = (ulong)(-value);
}
else
{
copy = (ulong)value;
}
do
{
byte ix = (byte)(copy % 100);
copy /= 100;
var chars = SpecialTypeNormal.DigitPairs[ix];
buffer[ptr--] = chars.Second;
buffer[ptr--] = chars.First;
} while (copy != 0);
if (buffer[ptr + 1] == '0')
{
ptr++;
}
handler.Writer.Append(buffer, ptr + 1, 35 - ptr);
}
internal static void WriteCollection(IEnumerable value, JsonSerializerHandler handler)
{
if (value == null)
{
handler.Writer.Append("null");
return;
}
var t = value.GetType();
if (t.IsGenericType)
{
var serializerAction = SerializerObjectJump.GetThreadSafetyJumpAction(t);
serializerAction(value, handler);
}
else
{
bool isMultidimensionalArray = false;
Array ary = null;
if (t.IsArray)
{
ary = (Array)value;
if (ary.Rank > 1)
{
isMultidimensionalArray = true;
}
}
if (isMultidimensionalArray)
{
WriteMultidimensionalArray(ary, handler);
}
else
{
WriteIEnumerable(value, handler);
}
}
}
internal static void WriteValue(ushort value, JsonSerializerHandler handler)
{
WriteValue((int)value, handler);
}
internal static void WriteValue(Guid value, JsonSerializerHandler handler)
{
handler.Writer.Append("\"");
char[] buffer = new char[36];
// 1314FAD4-7505-439D-ABD2-DBD89242928C
// 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
// 8 4 4 4 12,36 char,64byte
// guid -> int short short 8byte => 8byte 4byte 4byte 8byte
// Guid is guaranteed to be a 36 character string
// get all the dashes in place
buffer[8] = '-';
buffer[13] = '-';
buffer[18] = '-';
buffer[23] = '-';
// Bytes are in a different order than you might expect
// For: 35 91 8b c9 - 19 6d - 40 ea - 97 79 - 88 9d 79 b7 53 f0
// Get: C9 8B 91 35 6D 19 EA 40 97 79 88 9D 79 B7 53 F0
// Ix: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
//
// And we have to account for dashes
//
// So the map is like so:
// bytes[0] -> chars[3] -> buffer[ 6, 7]
// bytes[1] -> chars[2] -> buffer[ 4, 5]
// bytes[2] -> chars[1] -> buffer[ 2, 3]
// bytes[3] -> chars[0] -> buffer[ 0, 1]
// bytes[4] -> chars[5] -> buffer[11,12]
// bytes[5] -> chars[4] -> buffer[ 9,10]
// bytes[6] -> chars[7] -> buffer[16,17]
// bytes[7] -> chars[6] -> buffer[14,15]
// bytes[8] -> chars[8] -> buffer[19,20]
// bytes[9] -> chars[9] -> buffer[21,22]
// bytes[10] -> chars[10] -> buffer[24,25]
// bytes[11] -> chars[11] -> buffer[26,27]
// bytes[12] -> chars[12] -> buffer[28,29]
// bytes[13] -> chars[13] -> buffer[30,31]
// bytes[14] -> chars[14] -> buffer[32,33]
// bytes[15] -> chars[15] -> buffer[34,35]
var visibleMembers = new GuidStruct(value);
// bytes[0]
var b = visibleMembers.B00 * 2;
buffer[6] = WriteGuidLookup[b];
buffer[7] = WriteGuidLookup[b + 1];
// bytes[1]
b = visibleMembers.B01 * 2;
buffer[4] = WriteGuidLookup[b];
buffer[5] = WriteGuidLookup[b + 1];
// bytes[2]
b = visibleMembers.B02 * 2;
buffer[2] = WriteGuidLookup[b];
buffer[3] = WriteGuidLookup[b + 1];
// bytes[3]
b = visibleMembers.B03 * 2;
buffer[0] = WriteGuidLookup[b];
buffer[1] = WriteGuidLookup[b + 1];
// bytes[4]
b = visibleMembers.B04 * 2;
buffer[11] = WriteGuidLookup[b];
buffer[12] = WriteGuidLookup[b + 1];
// bytes[5]
b = visibleMembers.B05 * 2;
buffer[9] = WriteGuidLookup[b];
buffer[10] = WriteGuidLookup[b + 1];
// bytes[6]
b = visibleMembers.B06 * 2;
buffer[16] = WriteGuidLookup[b];
buffer[17] = WriteGuidLookup[b + 1];
// bytes[7]
b = visibleMembers.B07 * 2;
buffer[14] = WriteGuidLookup[b];
buffer[15] = WriteGuidLookup[b + 1];
// bytes[8]
b = visibleMembers.B08 * 2;
buffer[19] = WriteGuidLookup[b];
buffer[20] = WriteGuidLookup[b + 1];
// bytes[9]
b = visibleMembers.B09 * 2;
buffer[21] = WriteGuidLookup[b];
buffer[22] = WriteGuidLookup[b + 1];
// bytes[10]
b = visibleMembers.B10 * 2;
buffer[24] = WriteGuidLookup[b];
buffer[25] = WriteGuidLookup[b + 1];
// bytes[11]
b = visibleMembers.B11 * 2;
buffer[26] = WriteGuidLookup[b];
buffer[27] = WriteGuidLookup[b + 1];
// bytes[12]
b = visibleMembers.B12 * 2;
buffer[28] = WriteGuidLookup[b];
buffer[29] = WriteGuidLookup[b + 1];
// bytes[13]
b = visibleMembers.B13 * 2;
buffer[30] = WriteGuidLookup[b];
buffer[31] = WriteGuidLookup[b + 1];
// bytes[14]
b = visibleMembers.B14 * 2;
buffer[32] = WriteGuidLookup[b];
buffer[33] = WriteGuidLookup[b + 1];
// bytes[15]
b = visibleMembers.B15 * 2;
buffer[34] = WriteGuidLookup[b];
buffer[35] = WriteGuidLookup[b + 1];
handler.Writer.Append(buffer, 0, 36);
handler.Writer.Append("\"");
}
internal static void WriteValue(TimeSpan value, JsonSerializerHandler handler)
{
if (handler.Option.TimespanFormat == TimespanFormatEnum.ISO8601)
{
// can't negate this, have to handle it manually
if (value.Ticks == long.MinValue)
{
handler.Writer.Append("\"-P10675199DT2H48M5.4775808S\"");
return;
}
char[] buffer = new char[36];
handler.Writer.Append('"');
if (value.Ticks < 0)
{
handler.Writer.Append('-');
value = value.Negate();
}
handler.Writer.Append('P');
var days = value.Days;
var hours = value.Hours;
var minutes = value.Minutes;
var seconds = value.Seconds;
// days
if (days > 0)
{
_CustomWriteIntUnrolledSigned(handler.Writer, days, buffer);
handler.Writer.Append('D');
}
// time separator
handler.Writer.Append('T');
// hours
if (hours > 0)
{
_CustomWriteIntUnrolledSigned(handler.Writer, hours, buffer);
handler.Writer.Append('H');
}
// minutes
if (minutes > 0)
{
_CustomWriteIntUnrolledSigned(handler.Writer, minutes, buffer);
handler.Writer.Append('M');
}
// seconds
_CustomWriteIntUnrolledSigned(handler.Writer, seconds, buffer);
// fractional part
{
var endCount = 0;
var remainingTicks = (value - new TimeSpan(days, hours, minutes, seconds, 0)).Ticks;
if (remainingTicks > 0)
{
int fracEnd;
buffer[0] = '.';
var fracPart = remainingTicks % 100;
remainingTicks /= 100;
TwoDigits digits;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[7] = digits.Second;
buffer[6] = digits.First;
fracEnd = 8;
}
else
{
fracEnd = 6;
}
fracPart = remainingTicks % 100;
remainingTicks /= 100;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[5] = digits.Second;
buffer[4] = digits.First;
}
else
{
if (fracEnd == 6)
{
fracEnd = 4;
}
else
{
buffer[5] = '0';
buffer[4] = '0';
}
}
fracPart = remainingTicks % 100;
remainingTicks /= 100;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[3] = digits.Second;
buffer[2] = digits.First;
}
else
{
if (fracEnd == 4)
{
fracEnd = 2;
}
else
{
buffer[3] = '0';
buffer[2] = '0';
}
}
fracPart = remainingTicks;
buffer[1] = (char)('0' + fracPart);
endCount = fracEnd;
}
handler.Writer.Append(buffer, 0, endCount);
}
handler.Writer.Append("S\"");
}
else
{
if (value.Ticks == long.MinValue)
{
handler.Writer.Append("\"-10675199.02:48:05.4775808\"");
return;
}
char[] buffer = new char[36];
handler.Writer.Append('"');
if (value.Ticks < 0)
{
handler.Writer.Append('-');
value = value.Negate();
}
var days = value.Days;
var hours = value.Hours;
var minutes = value.Minutes;
var secs = value.Seconds;
TwoDigits digits;
// days
{
if (days != 0)
{
PrimitiveNormal.WriteValue(days, handler);
handler.Writer.Append('.');
}
}
// hours
{
digits = DigitPairs[hours];
buffer[0] = digits.First;
buffer[1] = digits.Second;
}
buffer[2] = ':';
// minutes
{
digits = DigitPairs[minutes];
buffer[3] = digits.First;
buffer[4] = digits.Second;
}
buffer[5] = ':';
// seconds
{
digits = DigitPairs[secs];
buffer[6] = digits.First;
buffer[7] = digits.Second;
}
int endCount = 8;
// factional part
{
var remainingTicks = (value - new TimeSpan(value.Days, value.Hours, value.Minutes, value.Seconds, 0)).Ticks;
if (remainingTicks > 0)
{
int fracEnd;
buffer[8] = '.';
var fracPart = remainingTicks % 100;
remainingTicks /= 100;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[15] = digits.Second;
buffer[14] = digits.First;
fracEnd = 16;
}
else
{
fracEnd = 14;
}
fracPart = remainingTicks % 100;
remainingTicks /= 100;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[13] = digits.Second;
buffer[12] = digits.First;
}
else
{
if (fracEnd == 14)
{
fracEnd = 12;
}
else
{
buffer[13] = '0';
buffer[12] = '0';
}
}
fracPart = remainingTicks % 100;
remainingTicks /= 100;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[11] = digits.Second;
buffer[10] = digits.First;
}
else
{
if (fracEnd == 12)
{
fracEnd = 10;
}
else
{
buffer[11] = '0';
buffer[10] = '0';
}
}
fracPart = remainingTicks;
buffer[9] = (char)('0' + fracPart);
endCount = fracEnd;
}
}
handler.Writer.Append(buffer, 0, endCount);
handler.Writer.Append('"');
}
}
internal static void WriteValue(DateTime value, JsonSerializerHandler handler)
{
if (handler.Option.DatetimeFormat == DatetimeFormatEnum.ISO8601)
{
// "yyyy-mm-ddThh:mm:ss.fffffffZ"
// 0123456789ABCDEFGHIJKL
//
// Yes, DateTime.Max is in fact guaranteed to have a 4 digit year (and no more)
// f of 7 digits allows for 1 Tick level resolution
char[] buffer = new char[36];
buffer[0] = '"';
// Year
uint val = (uint)value.Year;
var digits = DigitPairs[(byte)(val % 100)];
buffer[4] = digits.Second;
buffer[3] = digits.First;
digits = DigitPairs[(byte)(val / 100)];
buffer[2] = digits.Second;
buffer[1] = digits.First;
// delimiter
buffer[5] = '-';
// Month
digits = DigitPairs[value.Month];
buffer[7] = digits.Second;
buffer[6] = digits.First;
// Delimiter
buffer[8] = '-';
// Day
digits = DigitPairs[value.Day];
buffer[10] = digits.Second;
buffer[9] = digits.First;
// Delimiter
buffer[11] = 'T';
digits = DigitPairs[value.Hour];
buffer[13] = digits.Second;
buffer[12] = digits.First;
// Delimiter
buffer[14] = ':';
digits = DigitPairs[value.Minute];
buffer[16] = digits.Second;
buffer[15] = digits.First;
// Delimiter
buffer[17] = ':';
digits = DigitPairs[value.Second];
buffer[19] = digits.Second;
buffer[18] = digits.First;
int fracEnd;
var remainingTicks = (value - new DateTime(value.Year, value.Month, value.Day, value.Hour, value.Minute, value.Second)).Ticks;
if (remainingTicks > 0)
{
buffer[20] = '.';
var fracPart = remainingTicks % 100;
remainingTicks /= 100;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[27] = digits.Second;
buffer[26] = digits.First;
fracEnd = 28;
}
else
{
fracEnd = 26;
}
fracPart = remainingTicks % 100;
remainingTicks /= 100;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[25] = digits.Second;
buffer[24] = digits.First;
}
else
{
if (fracEnd == 26)
{
fracEnd = 24;
}
else
{
buffer[25] = '0';
buffer[24] = '0';
}
}
fracPart = remainingTicks % 100;
remainingTicks /= 100;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[23] = digits.Second;
buffer[22] = digits.First;
}
else
{
if (fracEnd == 24)
{
fracEnd = 22;
}
else
{
buffer[23] = '0';
buffer[22] = '0';
}
}
fracPart = remainingTicks;
buffer[21] = (char)('0' + fracPart);
}
else
{
fracEnd = 20;
}
buffer[fracEnd] = 'Z';
buffer[fracEnd + 1] = '"';
handler.Writer.Append(buffer, 0, fracEnd + 2);
}
else if (handler.Option.DatetimeFormat == DatetimeFormatEnum.RFC1123)
{
// ddd, dd MMM yyyy HH:mm:ss GMT'"
handler.Writer.Append('"');
// compiles as a switch
switch (value.DayOfWeek)
{
case DayOfWeek.Sunday: handler.Writer.Append("Sun, "); break;
case DayOfWeek.Monday: handler.Writer.Append("Mon, "); break;
case DayOfWeek.Tuesday: handler.Writer.Append("Tue, "); break;
case DayOfWeek.Wednesday: handler.Writer.Append("Wed, "); break;
case DayOfWeek.Thursday: handler.Writer.Append("Thu, "); break;
case DayOfWeek.Friday: handler.Writer.Append("Fri, "); break;
case DayOfWeek.Saturday: handler.Writer.Append("Sat, "); break;
}
{
var day = DigitPairs[value.Day];
handler.Writer.Append(day.First);
handler.Writer.Append(day.Second);
handler.Writer.Append(' ');
}
// compiles as a switch
switch (value.Month)
{
case 1: handler.Writer.Append("Jan "); break;
case 2: handler.Writer.Append("Feb "); break;
case 3: handler.Writer.Append("Mar "); break;
case 4: handler.Writer.Append("Apr "); break;
case 5: handler.Writer.Append("May "); break;
case 6: handler.Writer.Append("Jun "); break;
case 7: handler.Writer.Append("Jul "); break;
case 8: handler.Writer.Append("Aug "); break;
case 9: handler.Writer.Append("Sep "); break;
case 10: handler.Writer.Append("Oct "); break;
case 11: handler.Writer.Append("Nov "); break;
case 12: handler.Writer.Append("Dec "); break;
}
{
var year = value.Year;
var firstHalfYear = DigitPairs[year / 100];
handler.Writer.Append(firstHalfYear.First);
handler.Writer.Append(firstHalfYear.Second);
var secondHalfYear = DigitPairs[year % 100];
handler.Writer.Append(secondHalfYear.First);
handler.Writer.Append(secondHalfYear.Second);
handler.Writer.Append(' ');
}
{
var hour = DigitPairs[value.Hour];
handler.Writer.Append(hour.First);
handler.Writer.Append(hour.Second);
handler.Writer.Append(':');
}
{
var minute = DigitPairs[value.Minute];
handler.Writer.Append(minute.First);
handler.Writer.Append(minute.Second);
handler.Writer.Append(':');
}
{
var second = DigitPairs[value.Second];
handler.Writer.Append(second.First);
handler.Writer.Append(second.Second);
}
handler.Writer.Append(" GMT\"");
}
else if (handler.Option.DatetimeFormat == DatetimeFormatEnum.Microsoft)
{
/*
* "\/Date(628318530718)\/"
*/
handler.Writer.Append("\"\\/Date(");
handler.Writer.Append((value.Ticks - 621355968000000000L) / 10000L);
handler.Writer.Append(")\\/\"");
}
}
internal static void WriteValue(UIntPtr value, JsonSerializerHandler handler)
{
WriteValue((ulong)value, handler);
}
internal static unsafe void WriteValue(string value, JsonSerializerHandler handler)
{
/*
* string = quotation-mark *char quotation-mark
*
* char = unescaped /
* escape (
* %x22 / ; " quotation mark U+0022
* %x5C / ; \ reverse solidus U+005C
* %x2F / ; / solidus U+002F
* %x62 / ; b backspace U+0008
* %x66 / ; f form feed U+000C
* %x6E / ; n line feed U+000A
* %x72 / ; r carriage return U+000D
* %x74 / ; t tab U+0009
* %x75 4HEXDIG ) ; uXXXX U+XXXX
*
* escape = %x5C ; \
*
* quotation-mark = %x22 ; "
*
* unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
*/
if (value == null)
{
handler.Writer.Append("null");
return;
}
//handler.Writer.EnsureCapacity(handler.Writer.Capacity + value.Length);
handler.Writer.Append("\"");
fixed(char *strFixed = value)
{
char *str = strFixed;
char c;
var len = value.Length;
while (len > 0)
{
c = *str;
str++;
len--;
if (c == '\\')//\u005c //%x5c a\\b => a\u005cb
{
handler.Writer.Append(@"\\");
continue;
}
if (c == '"')//\u0022 //%x22
{
handler.Writer.Append("\\\"");
continue;
}
switch (c)
{
//%x00-x19
case '\u0000': handler.Writer.Append(@"\u0000"); continue;
case '\u0001': handler.Writer.Append(@"\u0001"); continue;
case '\u0002': handler.Writer.Append(@"\u0002"); continue;
case '\u0003': handler.Writer.Append(@"\u0003"); continue;
case '\u0004': handler.Writer.Append(@"\u0004"); continue;
case '\u0005': handler.Writer.Append(@"\u0005"); continue;
case '\u0006': handler.Writer.Append(@"\u0006"); continue;
case '\u0007': handler.Writer.Append(@"\u0007"); continue;
case '\u0008': handler.Writer.Append(@"\b"); continue;
case '\u0009': handler.Writer.Append(@"\t"); continue;
case '\u000A': handler.Writer.Append(@"\n"); continue;
case '\u000B': handler.Writer.Append(@"\u000b"); continue;
case '\u000C': handler.Writer.Append(@"\f"); continue;
case '\u000D': handler.Writer.Append(@"\r"); continue;
case '\u000E': handler.Writer.Append(@"\u000e"); continue;
case '\u000F': handler.Writer.Append(@"\u000f"); continue;
case '\u0010': handler.Writer.Append(@"\u0010"); continue;
case '\u0011': handler.Writer.Append(@"\u0011"); continue;
case '\u0012': handler.Writer.Append(@"\u0012"); continue;
case '\u0013': handler.Writer.Append(@"\u0013"); continue;
case '\u0014': handler.Writer.Append(@"\u0014"); continue;
case '\u0015': handler.Writer.Append(@"\u0015"); continue;
case '\u0016': handler.Writer.Append(@"\u0016"); continue;
case '\u0017': handler.Writer.Append(@"\u0017"); continue;
case '\u0018': handler.Writer.Append(@"\u0018"); continue;
case '\u0019': handler.Writer.Append(@"\u0019"); continue;
case '\u001A': handler.Writer.Append(@"\u001a"); continue;
case '\u001B': handler.Writer.Append(@"\u001b"); continue;
case '\u001C': handler.Writer.Append(@"\u001c"); continue;
case '\u001D': handler.Writer.Append(@"\u001d"); continue;
case '\u001E': handler.Writer.Append(@"\u001e"); continue;
case '\u001F': handler.Writer.Append(@"\u001f"); continue;
/*JavaScript */
case '\u0085': // Next Line
handler.Writer.Append(@"\u0085"); continue;
case '\u2028': // Line Separator
handler.Writer.Append(@"\u2028"); continue;
case '\u2029': // Paragraph Separator
handler.Writer.Append(@"\u2029"); continue;
default: handler.Writer.Append(c); continue;
}
}
}
handler.Writer.Append("\"");
}
internal static void WriteValue(char value, JsonSerializerHandler handler)
{
WriteValue(char.ToString(value), handler);
}
internal static void WriteValue(bool value, JsonSerializerHandler handler)
{
handler.Writer.Append(value ? "true" : "false");
}
internal static void AvoidTypes(object typeVar, JsonSerializerHandler handler)
{
handler.Writer.Append(typeVar == null ? "null" : "{}");
}
internal static void WriteValue(DBNull value, JsonSerializerHandler handler)
{
handler.Writer.Append("null");
}
internal static void Convert(T type, JsonSerializerHandler handler) => Get(type, handler);
internal static void WriteValue(StringBuilder value, JsonSerializerHandler handler)
{
if (value == null)
{
handler.Writer.Append("null");
}
else
{
handler.Writer.Append("\"");
for (int i = 0; i < value.Length; i++)
{
char c = value[i];
if (c == '\\')//\u005c //%x5c a\\b => a\u005cb
{
handler.Writer.Append(@"\\");
continue;
}
if (c == '"')//\u0022 //%x22
{
handler.Writer.Append("\\\"");
continue;
}
//如果是jsonp格式，多了 u2028 u2029的转换
switch (c)
{
//%x00-x19
case '\u0000': handler.Writer.Append(@"\u0000"); continue;
case '\u0001': handler.Writer.Append(@"\u0001"); continue;
case '\u0002': handler.Writer.Append(@"\u0002"); continue;
case '\u0003': handler.Writer.Append(@"\u0003"); continue;
case '\u0004': handler.Writer.Append(@"\u0004"); continue;
case '\u0005': handler.Writer.Append(@"\u0005"); continue;
case '\u0006': handler.Writer.Append(@"\u0006"); continue;
case '\u0007': handler.Writer.Append(@"\u0007"); continue;
case '\u0008': handler.Writer.Append(@"\b"); continue;
case '\u0009': handler.Writer.Append(@"\t"); continue;
case '\u000A': handler.Writer.Append(@"\n"); continue;
case '\u000B': handler.Writer.Append(@"\u000b"); continue;
case '\u000C': handler.Writer.Append(@"\f"); continue;
case '\u000D': handler.Writer.Append(@"\r"); continue;
case '\u000E': handler.Writer.Append(@"\u000e"); continue;
case '\u000F': handler.Writer.Append(@"\u000f"); continue;
case '\u0010': handler.Writer.Append(@"\u0010"); continue;
case '\u0011': handler.Writer.Append(@"\u0011"); continue;
case '\u0012': handler.Writer.Append(@"\u0012"); continue;
case '\u0013': handler.Writer.Append(@"\u0013"); continue;
case '\u0014': handler.Writer.Append(@"\u0014"); continue;
case '\u0015': handler.Writer.Append(@"\u0015"); continue;
case '\u0016': handler.Writer.Append(@"\u0016"); continue;
case '\u0017': handler.Writer.Append(@"\u0017"); continue;
case '\u0018': handler.Writer.Append(@"\u0018"); continue;
case '\u0019': handler.Writer.Append(@"\u0019"); continue;
case '\u001A': handler.Writer.Append(@"\u001a"); continue;
case '\u001B': handler.Writer.Append(@"\u001b"); continue;
case '\u001C': handler.Writer.Append(@"\u001c"); continue;
case '\u001D': handler.Writer.Append(@"\u001d"); continue;
case '\u001E': handler.Writer.Append(@"\u001e"); continue;
case '\u001F': handler.Writer.Append(@"\u001f"); continue;
default: handler.Writer.Append(c); continue;
}
}
handler.Writer.Append("\"");
}
}
internal static void WriteValue(decimal value, JsonSerializerHandler handler)
{
handler.Writer.Append(value.ToString(CultureInfo.InvariantCulture));
}
