// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
VerifyTypes(nominalType, actualType, typeof(DateTimeOffset));
BsonType bsonType = bsonReader.GetCurrentBsonType();
long ticks;
TimeSpan offset;
switch (bsonType)
{
case BsonType.Array:
bsonReader.ReadStartArray();
ticks = bsonReader.ReadInt64();
offset = TimeSpan.FromMinutes(bsonReader.ReadInt32());
bsonReader.ReadEndArray();
return new DateTimeOffset(ticks, offset);
case BsonType.Document:
bsonReader.ReadStartDocument();
bsonReader.ReadDateTime("DateTime"); // ignore value
ticks = bsonReader.ReadInt64("Ticks");
offset = TimeSpan.FromMinutes(bsonReader.ReadInt32("Offset"));
bsonReader.ReadEndDocument();
return new DateTimeOffset(ticks, offset);
case BsonType.String:
return XmlConvert.ToDateTimeOffset(bsonReader.ReadString());
default:
var message = string.Format("Cannot deserialize DateTimeOffset from BsonType {0}.", bsonType);
throw new Exception(message);
}
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
VerifyTypes(nominalType, actualType, typeof(BsonDateTime));
var bsonType = bsonReader.GetCurrentBsonType();
switch (bsonType)
{
case BsonType.DateTime:
var millisecondsSinceEpoch = bsonReader.ReadDateTime();
return new BsonDateTime(millisecondsSinceEpoch);
default:
var message = string.Format("Cannot deserialize BsonDateTime from BsonType {0}.", bsonType);
throw new Exception(message);
}
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
VerifyTypes(nominalType, actualType, typeof(DateTime));
var dateTimeSerializationOptions = EnsureSerializationOptions<DateTimeSerializationOptions>(options);
var bsonType = bsonReader.GetCurrentBsonType();
DateTime value;
switch (bsonType)
{
case BsonType.DateTime:
// use an intermediate BsonDateTime so MinValue and MaxValue are handled correctly
value = BsonDateTime.Create(bsonReader.ReadDateTime()).Value;
break;
case BsonType.Document:
bsonReader.ReadStartDocument();
bsonReader.ReadDateTime("DateTime"); // ignore value (use Ticks instead)
value = new DateTime(bsonReader.ReadInt64("Ticks"), DateTimeKind.Utc);
bsonReader.ReadEndDocument();
break;
case BsonType.Int64:
value = DateTime.SpecifyKind(new DateTime(bsonReader.ReadInt64()), DateTimeKind.Utc);
break;
case BsonType.String:
// note: we're not using XmlConvert because of bugs in Mono
if (dateTimeSerializationOptions.DateOnly)
{
value = DateTime.SpecifyKind(DateTime.ParseExact(bsonReader.ReadString(), "yyyy-MM-dd", null), DateTimeKind.Utc);
}
else
{
var formats = new string[] { "yyyy-MM-ddK", "yyyy-MM-ddTHH:mm:ssK", "yyyy-MM-ddTHH:mm:ss.FFFFFFFK" };
value = DateTime.ParseExact(bsonReader.ReadString(), formats, null, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
}
break;
default:
var message = string.Format("Cannot deserialize DateTime from BsonType {0}.", bsonType);
throw new FileFormatException(message);
}
if (dateTimeSerializationOptions.DateOnly)
{
if (value.TimeOfDay != TimeSpan.Zero)
{
throw new FileFormatException("TimeOfDay component for DateOnly DateTime value is not zero.");
}
value = DateTime.SpecifyKind(value, dateTimeSerializationOptions.Kind); // not ToLocalTime or ToUniversalTime!
}
else
{
switch (dateTimeSerializationOptions.Kind)
{
case DateTimeKind.Local:
case DateTimeKind.Unspecified:
value = DateTime.SpecifyKind(BsonUtils.ToLocalTime(value), dateTimeSerializationOptions.Kind);
break;
case DateTimeKind.Utc:
value = BsonUtils.ToUniversalTime(value);
break;
}
}
return value;
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
VerifyTypes(nominalType, actualType, typeof(BsonDateTime));
var dateTimeSerializationOptions = EnsureSerializationOptions<DateTimeSerializationOptions>(options);
var bsonType = bsonReader.GetCurrentBsonType();
if (bsonType == BsonType.Null)
{
bsonReader.ReadNull();
return null;
}
else
{
long? millisecondsSinceEpoch = null;
long? ticks = null;
switch (bsonType)
{
case BsonType.DateTime:
millisecondsSinceEpoch = bsonReader.ReadDateTime();
break;
case BsonType.Document:
bsonReader.ReadStartDocument();
millisecondsSinceEpoch = bsonReader.ReadDateTime("DateTime");
bsonReader.ReadName("Ticks");
var ticksValue = BsonValue.ReadFrom(bsonReader);
if (!ticksValue.IsBsonUndefined)
{
ticks = ticksValue.ToInt64();
}
bsonReader.ReadEndDocument();
break;
case BsonType.Int64:
ticks = bsonReader.ReadInt64();
break;
case BsonType.String:
// note: we're not using XmlConvert because of bugs in Mono
DateTime dateTime;
if (dateTimeSerializationOptions.DateOnly)
{
dateTime = DateTime.SpecifyKind(DateTime.ParseExact(bsonReader.ReadString(), "yyyy-MM-dd", null), DateTimeKind.Utc);
}
else
{
var formats = new string[] { "yyyy-MM-ddK", "yyyy-MM-ddTHH:mm:ssK", "yyyy-MM-ddTHH:mm:ss.FFFFFFFK", };
dateTime = DateTime.ParseExact(bsonReader.ReadString(), formats, null, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
}
ticks = dateTime.Ticks;
break;
default:
var message = string.Format("Cannot deserialize DateTime from BsonType {0}.", bsonType);
throw new FileFormatException(message);
}
BsonDateTime bsonDateTime;
if (ticks.HasValue)
{
bsonDateTime = BsonDateTime.Create(new DateTime(ticks.Value, DateTimeKind.Utc));
}
else
{
bsonDateTime = BsonDateTime.Create(millisecondsSinceEpoch.Value);
}
if (dateTimeSerializationOptions.DateOnly)
{
var dateTime = bsonDateTime.Value;
if (dateTime.TimeOfDay != TimeSpan.Zero)
{
throw new FileFormatException("TimeOfDay component for DateOnly DateTime value is not zero.");
}
bsonDateTime = BsonDateTime.Create(DateTime.SpecifyKind(dateTime, dateTimeSerializationOptions.Kind)); // not ToLocalTime or ToUniversalTime!
}
else
{
if (bsonDateTime.IsValidDateTime)
{
var dateTime = bsonDateTime.Value;
switch (dateTimeSerializationOptions.Kind)
{
case DateTimeKind.Local:
case DateTimeKind.Unspecified:
dateTime = DateTime.SpecifyKind(BsonUtils.ToLocalTime(dateTime), dateTimeSerializationOptions.Kind);
break;
case DateTimeKind.Utc:
dateTime = BsonUtils.ToUniversalTime(dateTime);
break;
}
bsonDateTime = BsonDateTime.Create(dateTime);
}
else
{
if (dateTimeSerializationOptions.Kind != DateTimeKind.Utc)
{
throw new FileFormatException("BsonDateTime is outside the range of .NET DateTime.");
}
}
}
return bsonDateTime;
}
}
public override object Deserialize(
BsonReader bsonReader,
Type nominalType
)
{
var bsonType = bsonReader.CurrentBsonType;
DateTime value;
switch (bsonType) {
case BsonType.DateTime:
value = bsonReader.ReadDateTime();
break;
case BsonType.String:
if (options.DateOnly) {
value = DateTime.SpecifyKind(DateTime.Parse(bsonReader.ReadString()), DateTimeKind.Utc);
} else {
value = XmlConvert.ToDateTime(bsonReader.ReadString(), XmlDateTimeSerializationMode.RoundtripKind);
}
break;
default:
var message = string.Format("Can't deserialize DateTime from BsonType: {0}", bsonType);
throw new FileFormatException(message);
}
if (options.DateOnly) {
if (value.TimeOfDay != TimeSpan.Zero) {
throw new FileFormatException("TimeOfDay component for DateOnly DateTime value is not zero");
}
value = DateTime.SpecifyKind(value, options.Kind); // not ToLocalTime or ToUniversalTime!
} else {
switch (options.Kind) {
case DateTimeKind.Local:
case DateTimeKind.Unspecified:
value = ToLocalTimeHelper(value, options.Kind);
break;
case DateTimeKind.Utc:
value = ToUniversalTimeHelper(value);
break;
}
}
return value;
}
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
IBsonSerializationOptions options
) {
DateTime value;
var bsonType = bsonReader.CurrentBsonType;
var dateTimeOptions = (options == null) ? DateTimeSerializationOptions.Defaults : (DateTimeSerializationOptions) options;
switch (bsonType) {
case BsonType.DateTime:
value = bsonReader.ReadDateTime();
break;
case BsonType.Document:
bsonReader.ReadStartDocument();
bsonReader.ReadDateTime("DateTime"); // ignore value (use Ticks instead)
value = DateTime.SpecifyKind(new DateTime(bsonReader.ReadInt64("Ticks")), DateTimeKind.Utc);
bsonReader.ReadEndDocument();
break;
case BsonType.Int64:
value = DateTime.SpecifyKind(new DateTime(bsonReader.ReadInt64()), DateTimeKind.Utc);
break;
case BsonType.String:
// note: we're not using XmlConvert because of bugs in Mono
if (dateTimeOptions.DateOnly) {
value = DateTime.SpecifyKind(DateTime.ParseExact(bsonReader.ReadString(), "yyyy-MM-dd", null), DateTimeKind.Utc);
} else {
var formats = new string[] {
"yyyy-MM-ddK",
"yyyy-MM-ddTHH:mm:ssK",
"yyyy-MM-ddTHH:mm:ss.FFFFFFFK",
};
value = DateTime.ParseExact(bsonReader.ReadString(), formats, null, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
}
break;
default:
var message = string.Format("Cannot deserialize DateTime from BsonType: {0}", bsonType);
throw new FileFormatException(message);
}
if (dateTimeOptions.DateOnly) {
if (value.TimeOfDay != TimeSpan.Zero) {
throw new FileFormatException("TimeOfDay component for DateOnly DateTime value is not zero");
}
value = DateTime.SpecifyKind(value, dateTimeOptions.Kind); // not ToLocalTime or ToUniversalTime!
} else {
switch (dateTimeOptions.Kind) {
case DateTimeKind.Local:
case DateTimeKind.Unspecified:
value = ToLocalTimeHelper(value, dateTimeOptions.Kind);
break;
case DateTimeKind.Utc:
value = ToUniversalTimeHelper(value);
break;
}
}
return value;
}
public void TestDateTimeStrictIso8601()
{
var json = "{ \"$date\" : \"1970-01-01T00:00:00Z\" }";
using (_bsonReader = new JsonReader(json))
{
Assert.AreEqual(BsonType.DateTime, _bsonReader.ReadBsonType());
Assert.AreEqual(0, _bsonReader.ReadDateTime());
Assert.AreEqual(BsonReaderState.Done, _bsonReader.State);
}
var expected = "{ \"$date\" : 0 }"; // it's still not ISO8601 on the way out
var jsonSettings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };
Assert.AreEqual(expected, BsonSerializer.Deserialize<DateTime>(json).ToJson(jsonSettings));
}
public void TestDateTimeStrict()
{
var json = "{ \"$date\" : 0 }";
using (_bsonReader = new JsonReader(json))
{
Assert.AreEqual(BsonType.DateTime, _bsonReader.ReadBsonType());
Assert.AreEqual(0, _bsonReader.ReadDateTime());
Assert.AreEqual(BsonReaderState.Done, _bsonReader.State);
}
var jsonSettings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };
Assert.AreEqual(json, BsonSerializer.Deserialize<DateTime>(json).ToJson(jsonSettings));
}
public void TestDateTimeShell()
{
var json = "ISODate(\"1970-01-01T00:00:00Z\")";
using (_bsonReader = new JsonReader(json))
{
Assert.AreEqual(BsonType.DateTime, _bsonReader.ReadBsonType());
Assert.AreEqual(0, _bsonReader.ReadDateTime());
Assert.AreEqual(BsonReaderState.Done, _bsonReader.State);
}
var jsonSettings = new JsonWriterSettings { OutputMode = JsonOutputMode.Shell };
Assert.AreEqual(json, BsonSerializer.Deserialize<DateTime>(json).ToJson(jsonSettings));
}
public void TestDateTimeMaxBson()
{
var json = "new Date(9223372036854775807)";
using (_bsonReader = new JsonReader(json))
{
Assert.AreEqual(BsonType.DateTime, _bsonReader.ReadBsonType());
Assert.AreEqual(9223372036854775807, _bsonReader.ReadDateTime());
Assert.AreEqual(BsonReaderState.Done, _bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize<BsonDateTime>(json).ToJson());
}
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
IBsonSerializationOptions options
)
{
DateTime value;
var bsonType = bsonReader.CurrentBsonType;
var dateTimeOptions = (options == null) ? DateTimeSerializationOptions.Defaults : (DateTimeSerializationOptions) options;
switch (bsonType) {
case BsonType.DateTime:
value = bsonReader.ReadDateTime();
break;
case BsonType.Document:
bsonReader.ReadStartDocument();
bsonReader.ReadDateTime("DateTime"); // ignore value (use Ticks instead)
value = DateTime.SpecifyKind(new DateTime(bsonReader.ReadInt64("Ticks")), DateTimeKind.Utc);
bsonReader.ReadEndDocument();
break;
case BsonType.Int64:
value = DateTime.SpecifyKind(new DateTime(bsonReader.ReadInt64()), DateTimeKind.Utc);
break;
case BsonType.String:
if (dateTimeOptions.DateOnly) {
value = DateTime.SpecifyKind(XmlConvert.ToDateTime(bsonReader.ReadString()), DateTimeKind.Utc);
} else {
value = XmlConvert.ToDateTime(bsonReader.ReadString(), XmlDateTimeSerializationMode.RoundtripKind);
}
break;
default:
var message = string.Format("Cannot deserialize DateTime from BsonType: {0}", bsonType);
throw new FileFormatException(message);
}
if (dateTimeOptions.DateOnly) {
if (value.TimeOfDay != TimeSpan.Zero) {
throw new FileFormatException("TimeOfDay component for DateOnly DateTime value is not zero");
}
value = DateTime.SpecifyKind(value, dateTimeOptions.Kind); // not ToLocalTime or ToUniversalTime!
} else {
switch (dateTimeOptions.Kind) {
case DateTimeKind.Local:
case DateTimeKind.Unspecified:
value = ToLocalTimeHelper(value, dateTimeOptions.Kind);
break;
case DateTimeKind.Utc:
value = ToUniversalTimeHelper(value);
break;
}
}
return value;
}
