public void Utc_Kind_DateTimeField_Deserializes_Utc_Time_From_Json_AsIs(DateParseHandling dateParseHandling)
{
var json = "{ \"Utc\": \"2017-11-23T11:40:51Z\" }";
var row = JsonConvert.DeserializeObject <DateTimeTestRow>(json, JsonSettings(dateParseHandling));
Assert.NotNull(row);
Assert.Equal(new DateTime(2017, 11, 23, 11, 40, 51, DateTimeKind.Utc), row.Utc);
Assert.Equal(DateTimeKind.Utc, row.Utc.Value.Kind);
}
// Token: 0x06000073 RID: 115
// RVA: 0x00006094 File Offset: 0x00004294
protected JsonReader()
{
this._currentState = JsonReader.State.Start;
this._stack = new List<JsonPosition>(4);
this._dateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
this._dateParseHandling = DateParseHandling.DateTime;
this._floatParseHandling = FloatParseHandling.Double;
this.CloseInput = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonReader"/> class with the specified <see cref="TextReader"/>.
/// </summary>
protected JsonReader()
{
_currentState = State.Start;
_dateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
_dateParseHandling = DateParseHandling.DateTime;
_floatParseHandling = FloatParseHandling.Double;
CloseInput = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonReader"/> class with the specified <see cref="TextReader"/>.
/// </summary>
protected JsonReader()
{
_currentState = State.Start;
_stack = new List <JsonPosition>(4);
_dateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
_dateParseHandling = DateParseHandling.DateTime;
CloseInput = true;
}
private static bool TryParseDateMicrosoft(string text, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, out object dt)
{
var value = text.Substring(6, text.Length - 8);
var kind = DateTimeKind.Utc;
var index = value.IndexOf('+', 1);
if (index == -1)
{
index = value.IndexOf('-', 1);
}
var offset = TimeSpan.Zero;
if (index != -1)
{
kind = DateTimeKind.Local;
offset = ReadOffset(value.Substring(index));
value = value.Substring(0, index);
}
long javaScriptTicks;
if (!long.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out javaScriptTicks))
{
dt = null;
return(false);
}
var utcDateTime = ConvertJavaScriptTicksToDateTime(javaScriptTicks);
if (dateParseHandling == DateParseHandling.DateTimeOffset)
{
dt = new DateTimeOffset(utcDateTime.Add(offset).Ticks, offset);
return(true);
}
DateTime dateTime;
switch (kind)
{
case DateTimeKind.Unspecified:
dateTime = DateTime.SpecifyKind(utcDateTime.ToLocalTime(), DateTimeKind.Unspecified);
break;
case DateTimeKind.Local:
dateTime = utcDateTime.ToLocalTime();
break;
default:
dateTime = utcDateTime;
break;
}
dt = EnsureDateTime(dateTime, dateTimeZoneHandling);
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonReader"/> class with the specified <see cref="TextReader"/>.
/// </summary>
protected JsonReader()
{
_currentState = State.Start;
_stack = new List <JsonPosition>(4);
_dateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
_dateParseHandling = DateParseHandling.None;
_floatParseHandling = FloatParseHandling.PreferDecimalFallbackToDouble;
CloseInput = true;
}
/// <summary>
/// Load a JObject from a string that contains JSON
/// </summary>
/// <param name="jObject">The jobject parameter</param>
/// <param name="json">A string that contains JSON.</param>
/// <param name="settings">The JsonLoadSettings used to load the JSON. If this is null,
/// default load settings will be used.</param>
/// <param name="dateParseHandling">The DateParseHandling settings value</param>
/// <returns>A JObject populated from the string that contains JSON.</returns>
public static JObject Parse(this JObject jObject, string json, JsonLoadSettings settings = null,
DateParseHandling dateParseHandling = DateParseHandling.None)
{
using (JsonReader reader = new JsonTextReader(new StringReader(json))
{
DateParseHandling = dateParseHandling
})
{
return(JObject.Load(reader, settings));
}
}
/// <summary>
/// Load a JArray from a string that contains JSON
/// </summary>
/// <param name="jArray">The JArray object</param>
/// <param name="json">A string that contains JSON.</param>
/// <param name="settings">The JsonLoadSettings used to load the JSON. If this is null,
/// default load settings will be used.</param>
/// <param name="dateParseHandling">The DateParseHandling settings value</param>
/// <param name="timeZoneHandling">The DateTimeZoneHandling settings value</param>
/// <returns>A JArray populated from the string that contains JSON.</returns>
public static JArray Parse(this JArray jArray, string json, JsonLoadSettings settings = null,
DateParseHandling dateParseHandling = DateParseHandling.None,
DateTimeZoneHandling timeZoneHandling = DateTimeZoneHandling.Unspecified)
{
using (JsonReader reader = new JsonTextReader(new StringReader(json))
{
DateParseHandling = dateParseHandling,
DateTimeZoneHandling = timeZoneHandling
})
{
return(JArray.Load(reader, settings));
}
}
internal static bool TryParseDateIso(
string text,
DateParseHandling dateParseHandling,
DateTimeZoneHandling dateTimeZoneHandling,
out object dt
)
{
const string isoDateFormat = "yyyy-MM-ddTHH:mm:ss.FFFFFFFK";
#if !NET20
if (dateParseHandling == DateParseHandling.DateTimeOffset)
{
DateTimeOffset dateTimeOffset;
if (
DateTimeOffset.TryParseExact(
text,
isoDateFormat,
CultureInfo.InvariantCulture,
DateTimeStyles.RoundtripKind,
out dateTimeOffset
)
)
{
dt = dateTimeOffset;
return(true);
}
}
else
#endif
{
DateTime dateTime;
if (
DateTime.TryParseExact(
text,
isoDateFormat,
CultureInfo.InvariantCulture,
DateTimeStyles.RoundtripKind,
out dateTime
)
)
{
dateTime = DateTimeUtils.EnsureDateTime(dateTime, dateTimeZoneHandling);
dt = dateTime;
return(true);
}
}
dt = null;
return(false);
}
private JsonSerializerSettings JsonSettings(DateParseHandling dateParseHandling)
{
var s = new JsonSerializerSettings
{
DateParseHandling = dateParseHandling,
TypeNameHandling = TypeNameHandling.None,
ReferenceLoopHandling = ReferenceLoopHandling.Error,
PreserveReferencesHandling = PreserveReferencesHandling.None
};
s.Converters.Add(new IsoDateTimeConverter());
s.Converters.Add(new JsonSafeInt64Converter());
return(s);
}
public static void WriteJson <T>(
string path,
T value,
DateParseHandling dateParseHandling = DateParseHandling.DateTimeOffset,
Formatting formatting = Formatting.Indented)
{
using var fileStream = new FileStream(path, FileMode.Create);
using var textWriter = new StreamWriter(fileStream);
using var jsonWriter = new JsonTextWriter(textWriter);
var serializer = GetJsonSerializer(dateParseHandling);
serializer.Formatting = formatting;
serializer.Serialize(jsonWriter, value);
}
public static bool TryParseDateMicrosoft(string text, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, out object dt)
{
string text2 = text.Substring(6, text.Length - 8);
DateTimeKind dateTimeKind = DateTimeKind.Utc;
int num = text2.IndexOf('+', 1);
if (num == -1)
{
num = text2.IndexOf('-', 1);
}
TimeSpan timeSpan = TimeSpan.Zero;
if (num != -1)
{
dateTimeKind = DateTimeKind.Local;
timeSpan = DateTimeUtils.ReadOffset(text2.Substring(num));
text2 = text2.Substring(0, num);
}
long javaScriptTicks;
if (!long.TryParse(text2, NumberStyles.Integer, CultureInfo.InvariantCulture, out javaScriptTicks))
{
dt = null;
return(false);
}
DateTime dateTime = DateTimeUtils.ConvertJavaScriptTicksToDateTime(javaScriptTicks);
if (dateParseHandling == DateParseHandling.DateTimeOffset)
{
dt = new DateTimeOffset(dateTime.Add(timeSpan).Ticks, timeSpan);
return(true);
}
DateTime value;
switch (dateTimeKind)
{
case DateTimeKind.Unspecified:
value = DateTime.SpecifyKind(dateTime.ToLocalTime(), DateTimeKind.Unspecified);
goto IL_C6;
case DateTimeKind.Local:
value = dateTime.ToLocalTime();
goto IL_C6;
}
value = dateTime;
IL_C6:
dt = DateTimeUtils.EnsureDateTime(value, dateTimeZoneHandling);
return(true);
}
private static bool TryParseDateExact(string text, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, string dateFormatString, CultureInfo culture, out object dt)
{
{
DateTime temp;
if (DateTime.TryParseExact(text, dateFormatString, culture, DateTimeStyles.RoundtripKind, out temp))
{
temp = EnsureDateTime(temp, dateTimeZoneHandling);
dt = temp;
return(true);
}
}
dt = null;
return(false);
}
/// <summary>
/// Tests the DateParseHandling property in a JSON serializer settings object.
/// </summary>
/// <param name="dateParseHandling">Expected DateParseHandling.</param>
/// <returns>The same JSON serializer settings test builder.</returns>
public IAndJsonSerializerSettingsTestBuilder WithDateParseHandling(DateParseHandling dateParseHandling)
{
this.jsonSerializerSettings.DateParseHandling = dateParseHandling;
this.validations.Add((expected, actual) =>
{
if (!CommonValidator.CheckEquality(expected.DateParseHandling, actual.DateParseHandling))
{
this.ThrowNewJsonResultAssertionException(
string.Format("{0} date parse handling", expected.DateParseHandling),
string.Format("in fact found {0}", actual.DateParseHandling));
}
});
return(this);
}
/// <summary>
/// Load a JObject from a string that contains JSON
/// </summary>
/// <param name="jObject">The jobject parameter</param>
/// <param name="json">A string that contains JSON.</param>
/// <param name="settings">The JsonLoadSettings used to load the JSON. If this is null,
/// default load settings will be used.</param>
/// <param name="dateParseHandling">The DateParseHandling settings value</param>
/// <param name="timeZoneHandling">The DateTimeZoneHandling settings value</param>
/// <param name="floatParseHandling">The FloatParseHandling settings value</param>
/// <returns>A JObject populated from the string that contains JSON.</returns>
public static JObject Parse(this JObject jObject, string json, JsonLoadSettings settings = null,
DateParseHandling dateParseHandling = DateParseHandling.None,
DateTimeZoneHandling timeZoneHandling = DateTimeZoneHandling.Unspecified,
FloatParseHandling floatParseHandling = FloatParseHandling.Decimal)
{
using (JsonReader reader = new JsonTextReader(new StringReader(json))
{
DateParseHandling = dateParseHandling,
DateTimeZoneHandling = timeZoneHandling,
FloatParseHandling = floatParseHandling
})
{
return(JObject.Load(reader, settings));
}
}
public void Issue477(DateParseHandling dateParseHandling)
{
var date = new DateTimeOffset(2021, 1, 1, 0, 0, 0, TimeSpan.Zero);
var filterJSON = JsonConvert.SerializeObject(new object[] { "this", date });
var deserializedFilter = JsonConvert.DeserializeObject <IList>(filterJSON, new JsonSerializerSettings {
DateParseHandling = dateParseHandling
});
var loadOptions = new SampleLoadOptions {
Filter = deserializedFilter
};
var loadResult = DataSourceLoader.Load(new[] { date }, loadOptions);
Assert.Single(loadResult.data);
}
/// <summary>
/// Attempts to parse a Json formatted string into a Newtonsoft.Json.Linq.JObject
/// </summary>
/// <param name="jsonText">The properly formmatted Json string</param>
/// <param name="jsonResult">The JObject representation</param>
/// <returns>True|False if parsing succeeded.</returns>
public static bool JObjectTryParse(string jsonText, out JObject jsonResult, DateParseHandling dateParseHandling = DateParseHandling.DateTime)
{
jsonResult = null;
bool ok = true;
try
{
var reader = new JsonTextReader(new StringReader(jsonText));
reader.DateParseHandling = dateParseHandling;
reader.CloseInput = true;
jsonResult = JObject.Load(reader);
} catch (Exception)
{
ok = false;
}
return(ok);
}
internal static bool smethod_13(string string_0, DateParseHandling dateParseHandling_0, DateTimeZoneHandling dateTimeZoneHandling_0, out object object_0)
{
if (string_0.Length > 0)
{
if (string_0[0] == '/')
{
if (string_0.StartsWith("/Date(", StringComparison.Ordinal) && string_0.EndsWith(")/", StringComparison.Ordinal))
{
return(smethod_14(string_0, dateParseHandling_0, dateTimeZoneHandling_0, out object_0));
}
}
else if (((string_0.Length >= 0x13) && (string_0.Length <= 40)) && (char.IsDigit(string_0[0]) && (string_0[10] == 'T')))
{
return(smethod_12(string_0, dateParseHandling_0, dateTimeZoneHandling_0, out object_0));
}
}
object_0 = null;
return(false);
}
public static XDocument DeserializeXNode(string json, DateParseHandling dateParseHandling,
string deserializeRootElementName = null, bool writeArrayAttribute = false, bool encodeSpecialCharacters = false)
{
var settings = new JsonSerializerSettings
{
Converters =
{
new Newtonsoft.Json.Converters.XmlNodeConverter()
{
DeserializeRootElementName = deserializeRootElementName,
WriteArrayAttribute = writeArrayAttribute,
EncodeSpecialCharacters = encodeSpecialCharacters
}
},
DateParseHandling = dateParseHandling,
};
return(JsonConvert.DeserializeObject <XDocument>(json, settings));
}
private static bool smethod_14(string string_0, DateParseHandling dateParseHandling_0, DateTimeZoneHandling dateTimeZoneHandling_0, out object object_0)
{
DateTime time2;
string s = string_0.Substring(6, string_0.Length - 8);
DateTimeKind utc = DateTimeKind.Utc;
int index = s.IndexOf('+', 1);
if (index == -1)
{
index = s.IndexOf('-', 1);
}
TimeSpan zero = TimeSpan.Zero;
if (index != -1)
{
utc = DateTimeKind.Local;
zero = smethod_15(s.Substring(index));
s = s.Substring(0, index);
}
DateTime time = smethod_11(long.Parse(s, NumberStyles.Integer, CultureInfo.InvariantCulture));
if (dateParseHandling_0 == DateParseHandling.DateTimeOffset)
{
object_0 = new DateTimeOffset(time.Add(zero).Ticks, zero);
return(true);
}
switch (utc)
{
case DateTimeKind.Unspecified:
time2 = DateTime.SpecifyKind(time.ToLocalTime(), DateTimeKind.Unspecified);
break;
case DateTimeKind.Local:
time2 = time.ToLocalTime();
break;
default:
time2 = time;
break;
}
object_0 = smethod_2(time2, dateTimeZoneHandling_0);
return(true);
}
internal static bool TryParseDateTime(string s, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, out object dt)
{
if (s.Length > 0)
{
if (s[0] == '/')
{
if (s.StartsWith("/Date(", StringComparison.Ordinal) && s.EndsWith(")/", StringComparison.Ordinal))
{
return(DateTimeUtils.TryParseDateMicrosoft(s, dateParseHandling, dateTimeZoneHandling, out dt));
}
}
else if (s.Length >= 19 && s.Length <= 40 && char.IsDigit(s[0]) && s[10] == 'T')
{
return(DateTimeUtils.TryParseDateIso(s, dateParseHandling, dateTimeZoneHandling, out dt));
}
}
dt = null;
return(false);
}
public static bool TryParseDateExact(string text, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, string dateFormatString, CultureInfo culture, out object dt)
{
DateTime dateTime;
if (dateParseHandling == DateParseHandling.DateTimeOffset)
{
DateTimeOffset dateTimeOffset;
if (DateTimeOffset.TryParseExact(text, dateFormatString, culture, DateTimeStyles.RoundtripKind, out dateTimeOffset))
{
dt = dateTimeOffset;
return(true);
}
}
else if (DateTime.TryParseExact(text, dateFormatString, culture, DateTimeStyles.RoundtripKind, out dateTime))
{
dateTime = DateTimeUtils.EnsureDateTime(dateTime, dateTimeZoneHandling);
dt = dateTime;
return(true);
}
dt = null;
return(false);
}
public static bool TryParseDateTime(string s, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, string dateFormatString, CultureInfo culture, out object dt)
{
if (s.Length > 0)
{
if (s[0] == '/')
{
if (s.StartsWith("/Date(", StringComparison.Ordinal) && s.EndsWith(")/", StringComparison.Ordinal) && DateTimeUtils.TryParseDateMicrosoft(s, dateParseHandling, dateTimeZoneHandling, out dt))
{
return(true);
}
}
else if (s.Length >= 19 && s.Length <= 40 && char.IsDigit(s[0]) && s[10] == 'T' && DateTimeUtils.TryParseDateIso(s, dateParseHandling, dateTimeZoneHandling, out dt))
{
return(true);
}
if (!string.IsNullOrEmpty(dateFormatString) && DateTimeUtils.TryParseDateExact(s, dateParseHandling, dateTimeZoneHandling, dateFormatString, culture, out dt))
{
return(true);
}
}
dt = null;
return(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonReader"/> class with the specified <see cref="TextReader"/>.
/// </summary>
protected JsonReader()
{
_currentState = State.Start;
_dateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
_dateParseHandling = DateParseHandling.DateTime;
_floatParseHandling = FloatParseHandling.Double;
CloseInput = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonReader"/> class with the specified <see cref="TextReader"/>.
/// </summary>
protected JsonReader()
{
_currentState = State.Start;
_stack = new List<JsonPosition>(4);
_dateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
_dateParseHandling = DateParseHandling.DateTime;
CloseInput = true;
}
public void SerializeObject_Then_DeserializeObjectAsDictionary_Sample_ShouldMatchJsonNet(FloatParseHandling floatParseHandling, DateParseHandling dateParseHandling)
{
var obj = CreateObject();
var expectedJson = Newtonsoft.Json.JsonConvert.SerializeObject(obj);
var expectedSettings = new Newtonsoft.Json.JsonSerializerSettings
{
FloatParseHandling = Enum.Parse <Newtonsoft.Json.FloatParseHandling>(floatParseHandling.ToString()),
DateParseHandling = Enum.Parse <Newtonsoft.Json.DateParseHandling>(dateParseHandling.ToString()),
};
var expected = Newtonsoft.Json.JsonConvert.DeserializeObject(expectedJson, typeof(Dictionary <string, object>), expectedSettings);
var actualJson = JsonConvert.SerializeObject(obj);
var actualSettings = new JsonSerializerSettings
{
FloatParseHandling = floatParseHandling,
DateParseHandling = dateParseHandling,
};
var actual = JsonConvert.DeserializeObject(actualJson, typeof(Dictionary <string, object>), actualSettings);
JsonDeepEqualAssert.Equal(expected, actual);
actual = JsonConvert.DeserializeObject <Dictionary <string, object> >(actualJson, actualSettings);
JsonDeepEqualAssert.Equal(expected, actual);
}
internal static bool TryParseDateIso(string text, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, out object dt)
{
DateTimeParser dateTimeParser = new DateTimeParser();
if (!dateTimeParser.Parse(text))
{
dt = null;
return(false);
}
DateTime d = new DateTime(dateTimeParser.Year, dateTimeParser.Month, dateTimeParser.Day, dateTimeParser.Hour, dateTimeParser.Minute, dateTimeParser.Second);
d = d.AddTicks(dateTimeParser.Fraction);
#if !NET20
if (dateParseHandling == DateParseHandling.DateTimeOffset)
{
TimeSpan offset;
switch (dateTimeParser.Zone)
{
case ParserTimeZone.Utc:
offset = new TimeSpan(0L);
break;
case ParserTimeZone.LocalWestOfUtc:
offset = new TimeSpan(-dateTimeParser.ZoneHour, -dateTimeParser.ZoneMinute, 0);
break;
case ParserTimeZone.LocalEastOfUtc:
offset = new TimeSpan(dateTimeParser.ZoneHour, dateTimeParser.ZoneMinute, 0);
break;
default:
offset = TimeZoneInfo.Local.GetUtcOffset(d);
break;
}
long ticks = d.Ticks - offset.Ticks;
if (ticks < 0 || ticks > 3155378975999999999)
{
dt = null;
return(false);
}
dt = new DateTimeOffset(d, offset);
return(true);
}
else
#endif
{
long ticks;
switch (dateTimeParser.Zone)
{
case ParserTimeZone.Utc:
d = new DateTime(d.Ticks, DateTimeKind.Utc);
break;
case ParserTimeZone.LocalWestOfUtc:
{
TimeSpan offset = new TimeSpan(dateTimeParser.ZoneHour, dateTimeParser.ZoneMinute, 0);
ticks = d.Ticks + offset.Ticks;
if (ticks <= DateTime.MaxValue.Ticks)
{
d = new DateTime(ticks, DateTimeKind.Utc).ToLocalTime();
}
else
{
ticks += d.GetUtcOffset().Ticks;
if (ticks > DateTime.MaxValue.Ticks)
{
ticks = DateTime.MaxValue.Ticks;
}
d = new DateTime(ticks, DateTimeKind.Local);
}
break;
}
case ParserTimeZone.LocalEastOfUtc:
{
TimeSpan offset = new TimeSpan(dateTimeParser.ZoneHour, dateTimeParser.ZoneMinute, 0);
ticks = d.Ticks - offset.Ticks;
if (ticks >= DateTime.MinValue.Ticks)
{
d = new DateTime(ticks, DateTimeKind.Utc).ToLocalTime();
}
else
{
ticks += d.GetUtcOffset().Ticks;
if (ticks < DateTime.MinValue.Ticks)
{
ticks = DateTime.MinValue.Ticks;
}
d = new DateTime(ticks, DateTimeKind.Local);
}
break;
}
}
dt = EnsureDateTime(d, dateTimeZoneHandling);
return(true);
}
}
public DateParseHandlingConverter(DateParseHandling dateParseHandling)
{
this.dateParseHandling = dateParseHandling;
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonReader"/> class with the specified <see cref="TextReader"/>.
/// </summary>
protected JsonReader()
{
_currentState = State.Start;
_stack = new List<JsonPosition>(4);
_dateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
_dateParseHandling = DateParseHandling.DateTime;
_floatParseHandling = FloatParseHandling.PreferDecimalFallbackToDouble;
CloseInput = true;
}
private static bool TryParseDateMicrosoft(string text, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, out object dt)
{
string value = text.Substring(6, text.Length - 8);
DateTimeKind kind = DateTimeKind.Utc;
int index = value.IndexOf('+', 1);
if (index == -1)
index = value.IndexOf('-', 1);
if (index != -1)
{
kind = DateTimeKind.Local;
value = value.Substring(0, index);
}
long javaScriptTicks;
if (!long.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out javaScriptTicks))
{
dt = null;
return false;
}
DateTime utcDateTime = ConvertJavaScriptTicksToDateTime(javaScriptTicks);
DateTime dateTime;
switch (kind)
{
case DateTimeKind.Unspecified:
dateTime = DateTime.SpecifyKind(utcDateTime.ToLocalTime(), DateTimeKind.Unspecified);
break;
case DateTimeKind.Local:
dateTime = utcDateTime.ToLocalTime();
break;
default:
dateTime = utcDateTime;
break;
}
dt = EnsureDateTime(dateTime, dateTimeZoneHandling);
return true;
}
private void SetupReader([Nullable(1)] JsonReader reader, out CultureInfo previousCulture, out DateTimeZoneHandling?previousDateTimeZoneHandling, out DateParseHandling?previousDateParseHandling, out FloatParseHandling?previousFloatParseHandling, out int?previousMaxDepth, out string previousDateFormatString)
{
if (this._culture != null && !this._culture.Equals(reader.Culture))
{
previousCulture = reader.Culture;
reader.Culture = this._culture;
}
else
{
previousCulture = null;
}
if (this._dateTimeZoneHandling != null)
{
DateTimeZoneHandling dateTimeZoneHandling = reader.DateTimeZoneHandling;
DateTimeZoneHandling?dateTimeZoneHandling2 = this._dateTimeZoneHandling;
if (!(dateTimeZoneHandling == dateTimeZoneHandling2.GetValueOrDefault() & dateTimeZoneHandling2 != null))
{
previousDateTimeZoneHandling = new DateTimeZoneHandling?(reader.DateTimeZoneHandling);
reader.DateTimeZoneHandling = this._dateTimeZoneHandling.GetValueOrDefault();
goto IL_9E;
}
}
previousDateTimeZoneHandling = null;
IL_9E:
if (this._dateParseHandling != null)
{
DateParseHandling dateParseHandling = reader.DateParseHandling;
DateParseHandling?dateParseHandling2 = this._dateParseHandling;
if (!(dateParseHandling == dateParseHandling2.GetValueOrDefault() & dateParseHandling2 != null))
{
previousDateParseHandling = new DateParseHandling?(reader.DateParseHandling);
reader.DateParseHandling = this._dateParseHandling.GetValueOrDefault();
goto IL_101;
}
}
previousDateParseHandling = null;
IL_101:
if (this._floatParseHandling != null)
{
FloatParseHandling floatParseHandling = reader.FloatParseHandling;
FloatParseHandling?floatParseHandling2 = this._floatParseHandling;
if (!(floatParseHandling == floatParseHandling2.GetValueOrDefault() & floatParseHandling2 != null))
{
previousFloatParseHandling = new FloatParseHandling?(reader.FloatParseHandling);
reader.FloatParseHandling = this._floatParseHandling.GetValueOrDefault();
goto IL_164;
}
}
previousFloatParseHandling = null;
IL_164:
if (this._maxDepthSet)
{
int?maxDepth = reader.MaxDepth;
int?maxDepth2 = this._maxDepth;
if (!(maxDepth.GetValueOrDefault() == maxDepth2.GetValueOrDefault() & maxDepth != null == (maxDepth2 != null)))
{
previousMaxDepth = reader.MaxDepth;
reader.MaxDepth = this._maxDepth;
goto IL_1CA;
}
}
previousMaxDepth = null;
IL_1CA:
if (this._dateFormatStringSet && reader.DateFormatString != this._dateFormatString)
{
previousDateFormatString = reader.DateFormatString;
reader.DateFormatString = this._dateFormatString;
}
else
{
previousDateFormatString = null;
}
JsonTextReader jsonTextReader = reader as JsonTextReader;
if (jsonTextReader != null && jsonTextReader.PropertyNameTable == null)
{
DefaultContractResolver defaultContractResolver = this._contractResolver as DefaultContractResolver;
if (defaultContractResolver != null)
{
jsonTextReader.PropertyNameTable = defaultContractResolver.GetNameTable();
}
}
}
internal static bool TryParseDateIso(string text, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, out object dt)
{
DateTimeParser dateTimeParser = new DateTimeParser();
if (!dateTimeParser.Parse(text))
{
dt = null;
return false;
}
DateTime d = new DateTime(dateTimeParser.Year, dateTimeParser.Month, dateTimeParser.Day, dateTimeParser.Hour, dateTimeParser.Minute, dateTimeParser.Second);
d = d.AddTicks(dateTimeParser.Fraction);
#if !NET20
if (dateParseHandling == DateParseHandling.DateTimeOffset)
{
TimeSpan offset;
switch (dateTimeParser.Zone)
{
case ParserTimeZone.Utc:
offset = new TimeSpan(0L);
break;
case ParserTimeZone.LocalWestOfUtc:
offset = new TimeSpan(-dateTimeParser.ZoneHour, -dateTimeParser.ZoneMinute, 0);
break;
case ParserTimeZone.LocalEastOfUtc:
offset = new TimeSpan(dateTimeParser.ZoneHour, dateTimeParser.ZoneMinute, 0);
break;
default:
offset = TimeZoneInfo.Local.GetUtcOffset(d);
break;
}
long ticks = d.Ticks - offset.Ticks;
if (ticks < 0 || ticks > 3155378975999999999)
{
dt = null;
return false;
}
dt = new DateTimeOffset(d, offset);
return true;
}
else
#endif
{
long ticks;
switch (dateTimeParser.Zone)
{
case ParserTimeZone.Utc:
d = new DateTime(d.Ticks, DateTimeKind.Utc);
break;
case ParserTimeZone.LocalWestOfUtc:
{
TimeSpan offset = new TimeSpan(dateTimeParser.ZoneHour, dateTimeParser.ZoneMinute, 0);
ticks = d.Ticks + offset.Ticks;
if (ticks <= DateTime.MaxValue.Ticks)
{
d = new DateTime(ticks, DateTimeKind.Utc).ToLocalTime();
}
else
{
ticks += d.GetUtcOffset().Ticks;
if (ticks > DateTime.MaxValue.Ticks)
ticks = DateTime.MaxValue.Ticks;
d = new DateTime(ticks, DateTimeKind.Local);
}
break;
}
case ParserTimeZone.LocalEastOfUtc:
{
TimeSpan offset = new TimeSpan(dateTimeParser.ZoneHour, dateTimeParser.ZoneMinute, 0);
ticks = d.Ticks - offset.Ticks;
if (ticks >= DateTime.MinValue.Ticks)
{
d = new DateTime(ticks, DateTimeKind.Utc).ToLocalTime();
}
else
{
ticks += d.GetUtcOffset().Ticks;
if (ticks < DateTime.MinValue.Ticks)
ticks = DateTime.MinValue.Ticks;
d = new DateTime(ticks, DateTimeKind.Local);
}
break;
}
}
dt = EnsureDateTime(d, dateTimeZoneHandling);
return true;
}
}
private static bool TryParseDateMicrosoft(string text, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, out object dt)
{
string value = text.Substring(6, text.Length - 8);
DateTimeKind kind = DateTimeKind.Utc;
int index = value.IndexOf('+', 1);
if (index == -1)
index = value.IndexOf('-', 1);
TimeSpan offset = TimeSpan.Zero;
if (index != -1)
{
kind = DateTimeKind.Local;
offset = ReadOffset(value.Substring(index));
value = value.Substring(0, index);
}
long javaScriptTicks = long.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture);
DateTime utcDateTime = ConvertJavaScriptTicksToDateTime(javaScriptTicks);
#if !NET20
if (dateParseHandling == DateParseHandling.DateTimeOffset)
{
dt = new DateTimeOffset(utcDateTime.Add(offset).Ticks, offset);
return true;
}
else
#endif
{
DateTime dateTime;
switch (kind)
{
case DateTimeKind.Unspecified:
dateTime = DateTime.SpecifyKind(utcDateTime.ToLocalTime(), DateTimeKind.Unspecified);
break;
case DateTimeKind.Local:
dateTime = utcDateTime.ToLocalTime();
break;
default:
dateTime = utcDateTime;
break;
}
dt = EnsureDateTime(dateTime, dateTimeZoneHandling);
return true;
}
}
// Token: 0x06000D22 RID: 3362
// RVA: 0x0004A6E8 File Offset: 0x000488E8
private static bool TryParseDateExact(string text, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, string dateFormatString, CultureInfo culture, out object dt)
{
DateTime dateTime;
if (DateTime.TryParseExact(text, dateFormatString, culture, DateTimeStyles.RoundtripKind, out dateTime))
{
dateTime = DateTimeUtils.EnsureDateTime(dateTime, dateTimeZoneHandling);
dt = dateTime;
return true;
}
dt = null;
return false;
}
// Token: 0x06000D1F RID: 3359
// RVA: 0x0004A3D4 File Offset: 0x000485D4
internal static bool TryParseDateIso(string text, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, out object dt)
{
DateTimeParser dateTimeParser = default(DateTimeParser);
if (!dateTimeParser.Parse(text))
{
dt = null;
return false;
}
DateTime dateTime = new DateTime(dateTimeParser.Year, dateTimeParser.Month, dateTimeParser.Day, dateTimeParser.Hour, dateTimeParser.Minute, dateTimeParser.Second);
dateTime = dateTime.AddTicks((long)dateTimeParser.Fraction);
switch (dateTimeParser.Zone)
{
case ParserTimeZone.Utc:
dateTime = new DateTime(dateTime.Ticks, DateTimeKind.Utc);
break;
case ParserTimeZone.LocalWestOfUtc:
{
TimeSpan timeSpan = new TimeSpan(dateTimeParser.ZoneHour, dateTimeParser.ZoneMinute, 0);
long num = dateTime.Ticks + timeSpan.Ticks;
if (num <= DateTime.MaxValue.Ticks)
{
dateTime = new DateTime(num, DateTimeKind.Utc).ToLocalTime();
}
else
{
num += DateTimeUtils.GetUtcOffset(dateTime).Ticks;
if (num > DateTime.MaxValue.Ticks)
{
num = DateTime.MaxValue.Ticks;
}
dateTime = new DateTime(num, DateTimeKind.Local);
}
break;
}
case ParserTimeZone.LocalEastOfUtc:
{
TimeSpan timeSpan2 = new TimeSpan(dateTimeParser.ZoneHour, dateTimeParser.ZoneMinute, 0);
long num = dateTime.Ticks - timeSpan2.Ticks;
if (num >= DateTime.MinValue.Ticks)
{
dateTime = new DateTime(num, DateTimeKind.Utc).ToLocalTime();
}
else
{
num += DateTimeUtils.GetUtcOffset(dateTime).Ticks;
if (num < DateTime.MinValue.Ticks)
{
num = DateTime.MinValue.Ticks;
}
dateTime = new DateTime(num, DateTimeKind.Local);
}
break;
}
}
dt = DateTimeUtils.EnsureDateTime(dateTime, dateTimeZoneHandling);
return true;
}
internal static bool TryParseDateIso(string text, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, out object dt)
{
const string isoDateFormat = "yyyy-MM-ddTHH:mm:ss.FFFFFFFK";
#if !NET20
if (dateParseHandling == DateParseHandling.DateTimeOffset)
{
DateTimeOffset dateTimeOffset;
if (DateTimeOffset.TryParseExact(text, isoDateFormat, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out dateTimeOffset))
{
dt = dateTimeOffset;
return true;
}
}
else
#endif
{
DateTime dateTime;
if (DateTime.TryParseExact(text, isoDateFormat, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out dateTime))
{
dateTime = DateTimeUtils.EnsureDateTime(dateTime, dateTimeZoneHandling);
dt = dateTime;
return true;
}
}
dt = null;
return false;
}
/// <summary>
/// Constructs an <see cref="ObjectConverter"/> with the specified options.
/// </summary>
/// <param name="floatParseHandling">Specifies how floating point numbers are parsed when reading JSON text.</param>
/// <param name="dateParseHandling">Specifies how date formatted strings are parsed when reading JSON text.</param>
public ObjectConverter(FloatParseHandling floatParseHandling, DateParseHandling dateParseHandling)
{
FloatParseHandling = floatParseHandling;
DateParseHandling = dateParseHandling;
}
public async Task ReadObjectAsync_HasDateTimeOffsetAttribute_PreservesTimeZone(DateParseHandling handling)
{
{
using var stream = new MemoryStream(
System.Text.Encoding.UTF8.GetBytes("{\"value\":\"2021-06-21T10:16:56.9714243+10:00\"}"));
var serializer = CreateDefaultJsonSerializer();
serializer.DateParseHandling = handling;
using var reader = new DefaultJsonStreamReader(stream, serializer);
Assert.True(await reader.InitializeAsync());
var value = await reader.ReadObjectAsync <JsonDocument>();
Assert.Equal(10, value.Value.Offset.Hours);
}
{
// check again, just in case the test was run in the +10 timezone and would have given a false positive.
using var stream = new MemoryStream(
System.Text.Encoding.UTF8.GetBytes("{\"value\":\"2021-06-21T10:16:56.9714243-8:00\"}"));
var serializer = CreateDefaultJsonSerializer();
serializer.DateParseHandling = handling;
using var reader = new DefaultJsonStreamReader(stream, serializer);
Assert.True(await reader.InitializeAsync());
var value = await reader.ReadObjectAsync <JsonDocument>();
Assert.Equal(-8, value.Value.Offset.Hours);
}
}
internal static bool TryParseDateTime(string s, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, out object dt)
{
if (s.Length > 0)
{
if (s[0] == '/')
{
if (s.StartsWith("/Date(", StringComparison.Ordinal) && s.EndsWith(")/", StringComparison.Ordinal))
{
return TryParseDateMicrosoft(s, dateParseHandling, dateTimeZoneHandling, out dt);
}
}
else if (s.Length >= 19 && s.Length <= 40 && char.IsDigit(s[0]) && s[10] == 'T')
{
return TryParseDateIso(s, dateParseHandling, dateTimeZoneHandling, out dt);
}
}
dt = null;
return false;
}
internal static bool TryParseDateTime(string s, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, string dateFormatString, CultureInfo culture, out object dt)
{
if (s.Length > 0)
{
if (s[0] == '/')
{
if (s.StartsWith("/Date(", StringComparison.Ordinal) && s.EndsWith(")/", StringComparison.Ordinal))
{
if (TryParseDateMicrosoft(s, dateParseHandling, dateTimeZoneHandling, out dt))
return true;
}
}
else if (s.Length >= 19 && s.Length <= 40 && char.IsDigit(s[0]) && s[10] == 'T')
{
if (TryParseDateIso(s, dateParseHandling, dateTimeZoneHandling, out dt))
return true;
}
if (!string.IsNullOrEmpty(dateFormatString))
{
if (TryParseDateExact(s, dateParseHandling, dateTimeZoneHandling, dateFormatString, culture, out dt))
return true;
}
}
dt = null;
return false;
}
internal static bool TryParseDateIso(string text, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, out object dt)
{
DateTimeParser dateTimeParser = default(DateTimeParser);
if (!dateTimeParser.Parse(text))
{
dt = null;
return(false);
}
DateTime dateTime = new DateTime(dateTimeParser.Year, dateTimeParser.Month, dateTimeParser.Day, dateTimeParser.Hour, dateTimeParser.Minute, dateTimeParser.Second);
dateTime = dateTime.AddTicks((long)dateTimeParser.Fraction);
if (dateParseHandling != DateParseHandling.DateTimeOffset)
{
switch (dateTimeParser.Zone)
{
case ParserTimeZone.Utc:
dateTime = new DateTime(dateTime.Ticks, DateTimeKind.Utc);
break;
case ParserTimeZone.LocalWestOfUtc:
{
TimeSpan timeSpan = new TimeSpan(dateTimeParser.ZoneHour, dateTimeParser.ZoneMinute, 0);
long num = dateTime.Ticks + timeSpan.Ticks;
if (num <= DateTime.MaxValue.Ticks)
{
dateTime = new DateTime(num, DateTimeKind.Utc).ToLocalTime();
}
else
{
num += dateTime.GetUtcOffset().Ticks;
if (num > DateTime.MaxValue.Ticks)
{
num = DateTime.MaxValue.Ticks;
}
dateTime = new DateTime(num, DateTimeKind.Local);
}
break;
}
case ParserTimeZone.LocalEastOfUtc:
{
TimeSpan timeSpan2 = new TimeSpan(dateTimeParser.ZoneHour, dateTimeParser.ZoneMinute, 0);
long num = dateTime.Ticks - timeSpan2.Ticks;
if (num >= DateTime.MinValue.Ticks)
{
dateTime = new DateTime(num, DateTimeKind.Utc).ToLocalTime();
}
else
{
num += dateTime.GetUtcOffset().Ticks;
if (num < DateTime.MinValue.Ticks)
{
num = DateTime.MinValue.Ticks;
}
dateTime = new DateTime(num, DateTimeKind.Local);
}
break;
}
}
dt = DateTimeUtils.EnsureDateTime(dateTime, dateTimeZoneHandling);
return(true);
}
TimeSpan utcOffset;
switch (dateTimeParser.Zone)
{
case ParserTimeZone.Utc:
utcOffset = new TimeSpan(0L);
break;
case ParserTimeZone.LocalWestOfUtc:
utcOffset = new TimeSpan(-dateTimeParser.ZoneHour, -dateTimeParser.ZoneMinute, 0);
break;
case ParserTimeZone.LocalEastOfUtc:
utcOffset = new TimeSpan(dateTimeParser.ZoneHour, dateTimeParser.ZoneMinute, 0);
break;
default:
utcOffset = TimeZoneInfo.Local.GetUtcOffset(dateTime);
break;
}
long num2 = dateTime.Ticks - utcOffset.Ticks;
if (num2 < 0L || num2 > 3155378975999999999L)
{
dt = null;
return(false);
}
dt = new DateTimeOffset(dateTime, utcOffset);
return(true);
}
private static bool TryParseDateExact(string text, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, string dateFormatString, CultureInfo culture, out object dt)
{
#if !NET20
if (dateParseHandling == DateParseHandling.DateTimeOffset)
{
DateTimeOffset temp;
if (DateTimeOffset.TryParseExact(text, dateFormatString, culture, DateTimeStyles.RoundtripKind, out temp))
{
dt = temp;
return true;
}
}
else
#endif
{
DateTime temp;
if (DateTime.TryParseExact(text, dateFormatString, culture, DateTimeStyles.RoundtripKind, out temp))
{
temp = EnsureDateTime(temp, dateTimeZoneHandling);
dt = temp;
return true;
}
}
dt = null;
return false;
}
internal virtual object DeserializeInternal(JsonReader reader, Type objectType)
{
ValidationUtils.ArgumentNotNull((object)reader, "reader");
CultureInfo cultureInfo = (CultureInfo)null;
if (this._culture != null && reader.Culture != this._culture)
{
cultureInfo = reader.Culture;
reader.Culture = this._culture;
}
DateTimeZoneHandling?nullable1 = new DateTimeZoneHandling?();
if (this._dateTimeZoneHandling.HasValue)
{
DateTimeZoneHandling timeZoneHandling = reader.DateTimeZoneHandling;
DateTimeZoneHandling?nullable2 = this._dateTimeZoneHandling;
if ((timeZoneHandling != nullable2.GetValueOrDefault() ? 1 : (!nullable2.HasValue ? 1 : 0)) != 0)
{
nullable1 = new DateTimeZoneHandling?(reader.DateTimeZoneHandling);
reader.DateTimeZoneHandling = this._dateTimeZoneHandling.Value;
}
}
DateParseHandling?nullable3 = new DateParseHandling?();
if (this._dateParseHandling.HasValue)
{
DateParseHandling dateParseHandling = reader.DateParseHandling;
DateParseHandling?nullable2 = this._dateParseHandling;
if ((dateParseHandling != nullable2.GetValueOrDefault() ? 1 : (!nullable2.HasValue ? 1 : 0)) != 0)
{
nullable3 = new DateParseHandling?(reader.DateParseHandling);
reader.DateParseHandling = this._dateParseHandling.Value;
}
}
int?nullable4 = new int?();
if (this._maxDepthSet)
{
int?maxDepth = reader.MaxDepth;
int?nullable2 = this._maxDepth;
if ((maxDepth.GetValueOrDefault() != nullable2.GetValueOrDefault() ? 1 : (maxDepth.HasValue != nullable2.HasValue ? 1 : 0)) != 0)
{
nullable4 = reader.MaxDepth;
reader.MaxDepth = this._maxDepth;
}
}
object obj = new JsonSerializerInternalReader(this).Deserialize(reader, objectType, this.CheckAdditionalContent);
if (cultureInfo != null)
{
reader.Culture = cultureInfo;
}
if (nullable1.HasValue)
{
reader.DateTimeZoneHandling = nullable1.Value;
}
if (nullable3.HasValue)
{
reader.DateParseHandling = nullable3.Value;
}
if (this._maxDepthSet)
{
reader.MaxDepth = nullable4;
}
return(obj);
}
// Token: 0x06000D21 RID: 3361
// RVA: 0x0004A63C File Offset: 0x0004883C
private static bool TryParseDateMicrosoft(string text, DateParseHandling dateParseHandling, DateTimeZoneHandling dateTimeZoneHandling, out object dt)
{
string text2 = text.Substring(6, text.Length - 8);
DateTimeKind dateTimeKind = DateTimeKind.Utc;
int num = text2.IndexOf('+', 1);
if (num == -1)
{
num = text2.IndexOf('-', 1);
}
if (num != -1)
{
dateTimeKind = DateTimeKind.Local;
text2 = text2.Substring(0, num);
}
long javaScriptTicks;
if (!long.TryParse(text2, NumberStyles.Integer, CultureInfo.InvariantCulture, out javaScriptTicks))
{
dt = null;
return false;
}
DateTime dateTime = DateTimeUtils.ConvertJavaScriptTicksToDateTime(javaScriptTicks);
DateTime value;
switch (dateTimeKind)
{
case DateTimeKind.Unspecified:
value = DateTime.SpecifyKind(dateTime.ToLocalTime(), DateTimeKind.Unspecified);
goto IL_8E;
case DateTimeKind.Local:
value = dateTime.ToLocalTime();
goto IL_8E;
}
value = dateTime;
IL_8E:
dt = DateTimeUtils.EnsureDateTime(value, dateTimeZoneHandling);
return true;
}
