public OXmlParagraphElement _Deserialize(BsonReader bsonReader, IBsonSerializationOptions options)
{
OXmlParagraphElement paragraph = new OXmlParagraphElement();
while (true)
{
BsonType bsonType = bsonReader.ReadBsonType();
if (bsonType == BsonType.EndOfDocument)
break;
//if (bsonType != BsonType.String)
// throw new PBException("error ZStringArray cannot contain value of type {0}", bsonType);
//var value = bsonReader.ReadString();
string name = bsonReader.ReadName();
switch (name.ToLower())
{
case "type":
if (bsonType != BsonType.String)
throw new PBException($"wrong type value {bsonType}");
string type = bsonReader.ReadString();
if (type.ToLower() != "paragraph")
throw new PBException($"invalid Type {type} when deserialize OXmlParagraphElement");
break;
case "style":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.String)
throw new PBException($"wrong style value {bsonType}");
paragraph.Style = bsonReader.ReadString();
break;
default:
throw new PBException($"unknow Paragraph value \"{name}\"");
}
}
return paragraph;
}
private static OXmlPageSize ReadPageSize(BsonReader bsonReader)
{
bsonReader.ReadStartDocument();
OXmlPageSize value = new OXmlPageSize();
while (true)
{
BsonType bsonType = bsonReader.ReadBsonType();
if (bsonType == BsonType.EndOfDocument)
break;
string name = bsonReader.ReadName();
switch (name.ToLower())
{
case "width":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.Int32)
throw new PBException($"wrong PageSize width value {bsonType}");
value.Width = bsonReader.ReadInt32();
break;
case "height":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.Int32)
throw new PBException($"wrong PageSize height value {bsonType}");
value.Height = bsonReader.ReadInt32();
break;
default:
throw new PBException($"unknow PageSize value \"{name}\"");
}
}
bsonReader.ReadEndDocument();
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(BsonNull));
var bsonType = bsonReader.GetCurrentBsonType();
string message;
switch (bsonType)
{
case BsonType.Null:
bsonReader.ReadNull();
return BsonNull.Value;
case BsonType.Document:
bsonReader.ReadStartDocument();
var name = bsonReader.ReadName();
if (name == "_csharpnull" || name == "$csharpnull")
{
var csharpNull = bsonReader.ReadBoolean();
bsonReader.ReadEndDocument();
return csharpNull ? null : BsonNull.Value;
}
else
{
message = string.Format("Unexpected element name while deserializing a BsonNull: {0}.", name);
throw new FileFormatException(message);
}
default:
message = string.Format("Cannot deserialize BsonNull from BsonType {0}.", bsonType);
throw new FileFormatException(message);
}
}
public OXmlSimpleFieldElement _Deserialize(BsonReader bsonReader, IBsonSerializationOptions options)
{
OXmlSimpleFieldElement element = new OXmlSimpleFieldElement();
while (true)
{
BsonType bsonType = bsonReader.ReadBsonType();
if (bsonType == BsonType.EndOfDocument)
break;
string name = bsonReader.ReadName();
switch (name.ToLower())
{
case "type":
if (bsonType != BsonType.String)
throw new PBException($"wrong type value {bsonType}");
string type = bsonReader.ReadString();
if (type.ToLower() != "simplefield")
throw new PBException($"invalid Type {type} when deserialize OXmlSimpleFieldElement");
break;
case "instruction":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.String)
throw new PBException($"wrong Instruction value {bsonType}");
element.Instruction = bsonReader.ReadString();
break;
default:
throw new PBException($"unknow SimpleField value \"{name}\"");
}
}
return element;
}
public OXmlOpenHeaderElement _Deserialize(BsonReader bsonReader, IBsonSerializationOptions options)
{
OXmlOpenHeaderElement element = new OXmlOpenHeaderElement();
while (true)
{
BsonType bsonType = bsonReader.ReadBsonType();
if (bsonType == BsonType.EndOfDocument)
break;
string name = bsonReader.ReadName();
switch (name.ToLower())
{
case "type":
if (bsonType != BsonType.String)
throw new PBException($"wrong type value {bsonType}");
string type = bsonReader.ReadString();
//"openfooter"
if (type.ToLower() != "openheader")
throw new PBException($"invalid Type {type} when deserialize OXmlOpenHeader");
break;
case "headertype":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.String)
throw new PBException($"wrong HeaderType value {bsonType}");
element.HeaderType = bsonReader.ReadString().zParseEnum<HeaderFooterValues>();
break;
default:
//OpenHeaderFooter
throw new PBException($"unknow OpenHeader value \"{name}\"");
}
}
return element;
}
// 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)
{
if (bsonReader.GetCurrentBsonType() == BsonType.Null)
{
bsonReader.ReadNull();
return null;
}
else
{
bsonReader.ReadStartDocument();
DeserializeType(bsonReader, "link");
bsonReader.ReadName("properties");
bsonReader.ReadStartDocument();
var href = bsonReader.ReadString("href");
string hrefType = null;
if (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
hrefType = bsonReader.ReadString("type");
}
bsonReader.ReadEndDocument();
bsonReader.ReadEndDocument();
return new GeoJsonLinkedCoordinateReferenceSystem(href, hrefType);
}
}
public object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options)
{
bsonReader.ReadStartDocument();
bsonReader.ReadName();
var typeName = bsonReader.ReadString();
bsonReader.ReadName();
var methodSignature = bsonReader.ReadString();
bsonReader.ReadEndDocument();
var type = Type.GetType(typeName);
if (type != null)
{
var method = type.GetMethods().Where(m => GetMethodSignature(m) == methodSignature).SingleOrDefault();
return method;
}
return null;
}
protected double? ReadNullableDouble(BsonReader reader,string name)
{
reader.ReadName(name);
var type = reader.GetCurrentBsonType();
if ( type == BsonType.Null)
{
reader.ReadNull();
return null;
}
return reader.ReadDouble();
}
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
IBsonSerializationOptions options
)
{
var bsonType = bsonReader.CurrentBsonType;
if (bsonType == BsonType.Null) {
bsonReader.ReadNull();
return null;
} else if (bsonType == BsonType.Document) {
var dictionary = CreateInstance(nominalType);
bsonReader.ReadStartDocument();
var discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(typeof(object));
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) {
var key = bsonReader.ReadName();
var valueType = discriminatorConvention.GetActualType(bsonReader, typeof(object));
var valueSerializer = BsonSerializer.LookupSerializer(valueType);
var value = valueSerializer.Deserialize(bsonReader, typeof(object), valueType, null);
dictionary.Add(key, value);
}
bsonReader.ReadEndDocument();
return dictionary;
} else if (bsonType == BsonType.Array) {
var dictionary = CreateInstance(nominalType);
bsonReader.ReadStartArray();
var discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(typeof(object));
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) {
bsonReader.SkipName();
bsonReader.ReadStartArray();
bsonReader.ReadBsonType();
bsonReader.SkipName();
var keyType = discriminatorConvention.GetActualType(bsonReader, typeof(object));
var keySerializer = BsonSerializer.LookupSerializer(keyType);
var key = keySerializer.Deserialize(bsonReader, typeof(object), keyType, null);
bsonReader.ReadBsonType();
bsonReader.SkipName();
var valueType = discriminatorConvention.GetActualType(bsonReader, typeof(object));
var valueSerializer = BsonSerializer.LookupSerializer(valueType);
var value = valueSerializer.Deserialize(bsonReader, typeof(object), valueType, null);
bsonReader.ReadEndArray();
dictionary.Add(key, value);
}
bsonReader.ReadEndArray();
return dictionary;
} else {
var message = string.Format("Can't deserialize a {0} from BsonType {1}", nominalType.FullName, bsonType);
throw new FileFormatException(message);
}
}
static PSObject ReadCustomObject(BsonReader bsonReader)
{
var ps = new PSObject();
var properties = ps.Properties;
bsonReader.ReadStartDocument();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var name = bsonReader.ReadName();
var value = ReadObject(bsonReader);
properties.Add(new PSNoteProperty(name, value), true); //! true is faster
}
bsonReader.ReadEndDocument();
return ps;
}
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
var bsonType = bsonReader.GetCurrentBsonType();
if (bsonType == BsonType.Null)
{
bsonReader.ReadNull();
return null;
}
else if (bsonType == BsonType.Document)
{
var dictionary = CreateInstance(nominalType);
bsonReader.ReadStartDocument();
var discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(object));
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var key = bsonReader.ReadName();
//TODO:对键进行字符串留用.Intern.
if (key.Length < 16)
{
key = String.Intern(key);
}
var valueType = discriminatorConvention.GetActualType(bsonReader, typeof(object));
var valueSerializer = BsonSerializer.LookupSerializer(valueType);
var value = valueSerializer.Deserialize(bsonReader, typeof(object), valueType, null);
//dictionary.Add(key, value);
if (dictionary is IDictionary<string, object>)
{
((IDictionary<string, object>)dictionary).Add(key, value);
}
else if (dictionary is IDictionary)
{
((IDictionary)dictionary).Add(key, value);
}
}
bsonReader.ReadEndDocument();
return dictionary;
}
else
{
var message = string.Format("Can't deserialize a {0} from BsonType {1}", nominalType.FullName, bsonType);
throw new FileFormatException(message);
}
}
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
IBsonSerializationOptions options
)
{
var nvc = new NameValueCollection();
bsonReader.ReadStartDocument();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var name = bsonReader.ReadName().Replace("__period__", ".");
var value = bsonReader.ReadString();
nvc.Add(name, value);
}
bsonReader.ReadEndDocument();
return nvc;
}
public override object Deserialize( BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options )
{
BsonType bsonType = bsonReader.CurrentBsonType;
object result;
if( bsonType == BsonType.Null )
{
bsonReader.ReadNull();
result = null;
}
else
{
if( bsonType == BsonType.Document )
{
var dictionary = new DynamicDictionary();
bsonReader.ReadStartDocument();
IDiscriminatorConvention valueDiscriminatorConvention = BsonSerializer.LookupDiscriminatorConvention( typeof( object ) );
while( bsonReader.ReadBsonType() != BsonType.EndOfDocument )
{
string key = bsonReader.ReadName();
Type valueType = valueDiscriminatorConvention.GetActualType( bsonReader, typeof( object ) );
IBsonSerializer valueSerializer = BsonSerializer.LookupSerializer( valueType );
object value = valueSerializer.Deserialize( bsonReader, typeof( object ), valueType, null );
if( key != "_t" )
{
dictionary.Add( key.Replace( '\x03', '.' ), value );
}
}
bsonReader.ReadEndDocument();
result = dictionary;
}
else
{
string message = string.Format( "Can't deserialize a {0} from BsonType {1}.", nominalType.FullName, bsonType );
throw new BsonException( message );
}
}
return result;
}
public OXmlDocSectionElement _Deserialize(BsonReader bsonReader, IBsonSerializationOptions options)
{
OXmlDocSectionElement element = new OXmlDocSectionElement();
while (true)
{
BsonType bsonType = bsonReader.ReadBsonType();
if (bsonType == BsonType.EndOfDocument)
break;
string name = bsonReader.ReadName();
switch (name.ToLower())
{
case "type":
if (bsonType != BsonType.String)
throw new PBException($"wrong type value {bsonType}");
string type = bsonReader.ReadString();
if (type.ToLower() != "docsection")
throw new PBException($"invalid Type {type} when deserialize OXmlDocSectionElement");
break;
case "pagesize":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.Document)
throw new PBException($"wrong PageSize value {bsonType}");
element.PageSize = ReadPageSize(bsonReader);
break;
case "pagemargin":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.Document)
throw new PBException($"wrong PageMargin value {bsonType}");
element.PageMargin = ReadPageMargin(bsonReader);
break;
case "pagenumberstart":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.Int32)
throw new PBException($"wrong PageNumberStart value {bsonType}");
element.PageNumberStart = bsonReader.ReadInt32();
break;
default:
throw new PBException($"unknow DocSection value \"{name}\"");
}
}
return element;
}
// public methods
public override object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options)
{
if (bsonReader.GetCurrentBsonType() == BsonType.Null)
{
bsonReader.ReadNull();
return null;
}
else
{
bsonReader.ReadStartDocument();
DeserializeType(bsonReader, "name");
bsonReader.ReadName("properties");
bsonReader.ReadStartDocument();
var name = bsonReader.ReadString("name");
bsonReader.ReadEndDocument();
bsonReader.ReadEndDocument();
return new GeoJsonNamedCoordinateReferenceSystem(name);
}
}
public Type GetActualType(
BsonReader bsonReader,
Type nominalType
) {
var bookmark = bsonReader.GetBookmark();
bsonReader.ReadStartDocument();
var actualType = nominalType;
while(bsonReader.ReadBsonType() != BsonType.EndOfDocument) {
var name = bsonReader.ReadName();
if(name == "OnlyInB") {
actualType = typeof(B);
break;
}
else if(name == "OnlyInC") {
actualType = typeof(C);
break;
}
bsonReader.SkipValue();
}
bsonReader.ReturnToBookmark(bookmark);
return actualType;
}
// 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(BsonDocument));
var bsonType = bsonReader.GetCurrentBsonType();
string message;
switch (bsonType)
{
case BsonType.Document:
var documentSerializationOptions = (options ?? DocumentSerializationOptions.Defaults) as DocumentSerializationOptions;
if (documentSerializationOptions == null)
{
message = string.Format(
"Serialize method of BsonDocument expected serialization options of type {0}, not {1}.",
BsonUtils.GetFriendlyTypeName(typeof(DocumentSerializationOptions)),
BsonUtils.GetFriendlyTypeName(options.GetType()));
throw new BsonSerializationException(message);
}
bsonReader.ReadStartDocument();
var document = new BsonDocument(documentSerializationOptions.AllowDuplicateNames);
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var name = bsonReader.ReadName();
var value = (BsonValue)BsonValueSerializer.Instance.Deserialize(bsonReader, typeof(BsonValue), null);
document.Add(name, value);
}
bsonReader.ReadEndDocument();
return document;
default:
message = string.Format("Cannot deserialize BsonDocument from BsonType {0}.", bsonType);
throw new FileFormatException(message);
}
}
public OXmlTextElement _Deserialize(BsonReader bsonReader, IBsonSerializationOptions options)
{
OXmlTextElement element = new OXmlTextElement();
while (true)
{
BsonType bsonType = bsonReader.ReadBsonType();
if (bsonType == BsonType.EndOfDocument)
break;
string name = bsonReader.ReadName();
switch (name.ToLower())
{
case "type":
if (bsonType != BsonType.String)
throw new PBException($"wrong type value {bsonType}");
string type = bsonReader.ReadString();
if (type.ToLower() != "text")
throw new PBException($"invalid Type {type} when deserialize OXmlTextElement");
break;
case "text":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.String)
throw new PBException($"wrong text value {bsonType}");
element.Text = bsonReader.ReadString();
break;
case "preservespace":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.Boolean)
throw new PBException($"wrong PreserveSpace value {bsonType}");
element.PreserveSpace = bsonReader.ReadBoolean();
break;
default:
throw new PBException($"unknow Text value \"{name}\"");
}
}
return element;
}
public OXmlDocDefaultsRunPropertiesElement _Deserialize(BsonReader bsonReader, IBsonSerializationOptions options)
{
OXmlDocDefaultsRunPropertiesElement element = new OXmlDocDefaultsRunPropertiesElement();
while (true)
{
BsonType bsonType = bsonReader.ReadBsonType();
if (bsonType == BsonType.EndOfDocument)
break;
string name = bsonReader.ReadName();
switch (name.ToLower())
{
case "type":
if (bsonType != BsonType.String)
throw new PBException($"wrong type value {bsonType}");
string type = bsonReader.ReadString();
if (type.ToLower() != "docdefaultsrunproperties")
throw new PBException($"invalid Type {type} when deserialize OXmlDocDefaultsRunPropertiesElement");
break;
case "runfonts":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.Document)
throw new PBException($"wrong RunFonts value {bsonType}");
element.RunFonts = OXmlCommonSerializer.ReadRunFonts(bsonReader);
break;
case "fontsize":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.String)
throw new PBException($"wrong FontSize value {bsonType}");
element.FontSize = bsonReader.ReadString();
break;
default:
throw new PBException($"unknow DocDefaultsRunProperties value \"{name}\"");
}
}
return element;
}
public override object Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options)
{
dynamic item = new ebayItemDataForSeller();
IDictionary<String, Object> dict = new Dictionary<String, Object>();
bsonReader.ReadStartDocument();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var elementName = bsonReader.ReadName();
var pi = nominalType.GetProperty(elementName);
if (pi != null)
{
dynamic data = null;
if (bsonReader.CurrentBsonType.Equals(BsonType.Null))
{
bsonReader.ReadNull();
}
else
{
data = BsonDefaultSerializer.Instance.GetSerializer(pi.PropertyType).Deserialize(bsonReader, pi.PropertyType, options);
this.GetType().GetProperty(pi.Name).SetValue(item, data, null);
}
}
else
{
if (bsonReader.CurrentBsonType.Equals(BsonType.Null))
{
bsonReader.SkipValue();
}
else dict[elementName] = bsonReader.ReadString();
}
}
bsonReader.ReadEndDocument();
item.SetDynamics(dict);
return this;
}
// 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)
{
var arraySerializationOptions = EnsureSerializationOptions<ArraySerializationOptions>(options);
var itemSerializationOptions = arraySerializationOptions.ItemSerializationOptions;
var bsonType = bsonReader.GetCurrentBsonType();
switch (bsonType)
{
case BsonType.Null:
bsonReader.ReadNull();
return null;
case BsonType.Array:
bsonReader.ReadStartArray();
var queue = new Queue();
var discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(object));
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var elementType = discriminatorConvention.GetActualType(bsonReader, typeof(object));
var serializer = BsonSerializer.LookupSerializer(elementType);
var element = serializer.Deserialize(bsonReader, typeof(object), elementType, itemSerializationOptions);
queue.Enqueue(element);
}
bsonReader.ReadEndArray();
return queue;
case BsonType.Document:
bsonReader.ReadStartDocument();
bsonReader.ReadString("_t"); // skip over discriminator
bsonReader.ReadName("_v");
var value = Deserialize(bsonReader, actualType, actualType, options);
bsonReader.ReadEndDocument();
return value;
default:
var message = string.Format("Can't deserialize a {0} from BsonType {1}.", nominalType.FullName, bsonType);
throw new FileFormatException(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 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;
}
}
// explicit interface implementation
object IBsonSerializable.Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options)
{
if (bsonReader.CurrentBsonType == Bson.BsonType.Null)
{
bsonReader.ReadNull();
return null;
}
else
{
bsonReader.ReadStartDocument();
BsonType bsonType;
while ((bsonType = bsonReader.ReadBsonType()) != BsonType.EndOfDocument)
{
var name = bsonReader.ReadName();
switch (name)
{
case "abbreviated":
_abbreviated = bsonReader.ReadString();
break;
case "client":
_client = bsonReader.ReadString();
break;
case "command":
_command = BsonDocument.ReadFrom(bsonReader);
break;
case "cursorid":
_cursorId = BsonValue.ReadFrom(bsonReader).ToInt64();
break;
case "err":
_error = bsonReader.ReadString();
break;
case "exception":
_exception = bsonReader.ReadString();
break;
case "exceptionCode":
_exceptionCode = BsonValue.ReadFrom(bsonReader).ToInt32();
break;
case "exhaust":
_exhaust = BsonValue.ReadFrom(bsonReader).ToBoolean();
break;
case "fastmod":
_fastMod = BsonValue.ReadFrom(bsonReader).ToBoolean();
break;
case "fastmodinsert":
_fastModInsert = BsonValue.ReadFrom(bsonReader).ToBoolean();
break;
case "idhack":
_idHack = BsonValue.ReadFrom(bsonReader).ToBoolean();
break;
case "info":
_info = bsonReader.ReadString();
break;
case "keyUpdates":
_keyUpdates = BsonValue.ReadFrom(bsonReader).ToInt32();
break;
case "millis":
_duration = TimeSpan.FromMilliseconds(BsonValue.ReadFrom(bsonReader).ToDouble());
break;
case "moved":
_moved = BsonValue.ReadFrom(bsonReader).ToBoolean();
break;
case "nreturned":
_numberReturned = BsonValue.ReadFrom(bsonReader).ToInt32();
break;
case "ns":
_namespace = bsonReader.ReadString();
break;
case "nscanned":
_numberScanned = BsonValue.ReadFrom(bsonReader).ToInt32();
break;
case "ntoreturn":
_numberToReturn = BsonValue.ReadFrom(bsonReader).ToInt32();
break;
case "ntoskip":
_numberToSkip = BsonValue.ReadFrom(bsonReader).ToInt32();
break;
case "op":
_op = bsonReader.ReadString();
break;
case "query":
_query = BsonDocument.ReadFrom(bsonReader);
break;
case "responseLength":
_responseLength = BsonValue.ReadFrom(bsonReader).ToInt32();
break;
case "scanAndOrder":
_scanAndOrder = BsonValue.ReadFrom(bsonReader).ToBoolean();
break;
case "ts":
_timestamp = BsonUtils.ToDateTimeFromMillisecondsSinceEpoch(bsonReader.ReadDateTime());
break;
case "updateobj":
_updateObject = BsonDocument.ReadFrom(bsonReader);
break;
case "upsert":
_upsert = BsonValue.ReadFrom(bsonReader).ToBoolean();
break;
case "user":
_user = bsonReader.ReadString();
break;
default:
break; // ignore unknown elements
}
}
bsonReader.ReadEndDocument();
return this;
}
}
public void TestNestedDocument() {
var json = "{ \"a\" : { \"b\" : 1, \"c\" : 2 } }";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.Document, bsonReader.ReadBsonType());
bsonReader.ReadStartDocument();
Assert.AreEqual(BsonType.Document, bsonReader.ReadBsonType());
Assert.AreEqual("a", bsonReader.ReadName());
bsonReader.ReadStartDocument();
Assert.AreEqual("b", bsonReader.ReadName());
Assert.AreEqual(1, bsonReader.ReadInt32());
Assert.AreEqual("c", bsonReader.ReadName());
Assert.AreEqual(2, bsonReader.ReadInt32());
bsonReader.ReadEndDocument();
bsonReader.ReadEndDocument();
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize<BsonDocument>(new StringReader(json)).ToJson());
}
public void TestBookmark() {
var json = "{ \"x\" : 1, \"y\" : 2 }";
using (bsonReader = BsonReader.Create(json)) {
// do everything twice returning to bookmark in between
var bookmark = bsonReader.GetBookmark();
Assert.AreEqual(BsonType.Document, bsonReader.ReadBsonType());
bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(BsonType.Document, bsonReader.ReadBsonType());
bookmark = bsonReader.GetBookmark();
bsonReader.ReadStartDocument();
bsonReader.ReturnToBookmark(bookmark);
bsonReader.ReadStartDocument();
bookmark = bsonReader.GetBookmark();
Assert.AreEqual(BsonType.Int32, bsonReader.ReadBsonType());
bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(BsonType.Int32, bsonReader.ReadBsonType());
bookmark = bsonReader.GetBookmark();
Assert.AreEqual("x", bsonReader.ReadName());
bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual("x", bsonReader.ReadName());
bookmark = bsonReader.GetBookmark();
Assert.AreEqual(1, bsonReader.ReadInt32());
bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(1, bsonReader.ReadInt32());
bookmark = bsonReader.GetBookmark();
Assert.AreEqual(BsonType.Int32, bsonReader.ReadBsonType());
bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(BsonType.Int32, bsonReader.ReadBsonType());
bookmark = bsonReader.GetBookmark();
Assert.AreEqual("y", bsonReader.ReadName());
bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual("y", bsonReader.ReadName());
bookmark = bsonReader.GetBookmark();
Assert.AreEqual(2, bsonReader.ReadInt32());
bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(2, bsonReader.ReadInt32());
bookmark = bsonReader.GetBookmark();
Assert.AreEqual(BsonType.EndOfDocument, bsonReader.ReadBsonType());
bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(BsonType.EndOfDocument, bsonReader.ReadBsonType());
bookmark = bsonReader.GetBookmark();
bsonReader.ReadEndDocument();
bsonReader.ReturnToBookmark(bookmark);
bsonReader.ReadEndDocument();
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize<BsonDocument>(new StringReader(json)).ToJson());
}
public void TestJavaScriptWithScope() {
string json = "{ \"$code\" : \"function f() { return n; }\", \"$scope\" : { \"n\" : 1 } }";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.JavaScriptWithScope, bsonReader.ReadBsonType());
Assert.AreEqual("function f() { return n; }", bsonReader.ReadJavaScriptWithScope());
bsonReader.ReadStartDocument();
Assert.AreEqual(BsonType.Int32, bsonReader.ReadBsonType());
Assert.AreEqual("n", bsonReader.ReadName());
Assert.AreEqual(1, bsonReader.ReadInt32());
bsonReader.ReadEndDocument();
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize<BsonJavaScriptWithScope>(new StringReader(json)).ToJson());
}
public void TestDocumentTwoElements() {
var json = "{ \"x\" : 1, \"y\" : 2 }";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.Document, bsonReader.ReadBsonType());
bsonReader.ReadStartDocument();
Assert.AreEqual(BsonType.Int32, bsonReader.ReadBsonType());
Assert.AreEqual("x", bsonReader.ReadName());
Assert.AreEqual(1, bsonReader.ReadInt32());
Assert.AreEqual(BsonType.Int32, bsonReader.ReadBsonType());
Assert.AreEqual("y", bsonReader.ReadName());
Assert.AreEqual(2, bsonReader.ReadInt32());
Assert.AreEqual(BsonType.EndOfDocument, bsonReader.ReadBsonType());
bsonReader.ReadEndDocument();
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize<BsonDocument>(new StringReader(json)).ToJson());
}
// 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)
{
var dictionarySerializationOptions = EnsureSerializationOptions(options);
var dictionaryRepresentation = dictionarySerializationOptions.Representation;
var keyValuePairSerializationOptions = dictionarySerializationOptions.KeyValuePairSerializationOptions;
var bsonType = bsonReader.GetCurrentBsonType();
if (bsonType == BsonType.Null)
{
bsonReader.ReadNull();
return null;
}
else if (bsonType == BsonType.Document)
{
if (nominalType == typeof(object))
{
bsonReader.ReadStartDocument();
bsonReader.ReadString("_t"); // skip over discriminator
bsonReader.ReadName("_v");
var value = Deserialize(bsonReader, actualType, options); // recursive call replacing nominalType with actualType
bsonReader.ReadEndDocument();
return value;
}
var dictionary = CreateInstance(actualType);
var valueDiscriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(object));
bsonReader.ReadStartDocument();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var key = bsonReader.ReadName();
var valueType = valueDiscriminatorConvention.GetActualType(bsonReader, typeof(object));
var valueSerializer = BsonSerializer.LookupSerializer(valueType);
var value = valueSerializer.Deserialize(bsonReader, typeof(object), valueType, keyValuePairSerializationOptions.ValueSerializationOptions);
dictionary.Add(key, value);
}
bsonReader.ReadEndDocument();
return dictionary;
}
else if (bsonType == BsonType.Array)
{
var dictionary = CreateInstance(actualType);
bsonReader.ReadStartArray();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var keyValuePair = (KeyValuePair<object, object>)_keyValuePairSerializer.Deserialize(
bsonReader,
typeof(KeyValuePair<object, object>),
keyValuePairSerializationOptions);
dictionary.Add(keyValuePair.Key, keyValuePair.Value);
}
bsonReader.ReadEndArray();
return dictionary;
}
else
{
var message = string.Format("Can't deserialize a {0} from BsonType {1}.", nominalType.FullName, bsonType);
throw new FileFormatException(message);
}
}
public void TestNestedArray()
{
var json = "{ \"a\" : [1, 2] }";
using (_bsonReader = new JsonReader(json))
{
Assert.AreEqual(BsonType.Document, _bsonReader.ReadBsonType());
_bsonReader.ReadStartDocument();
Assert.AreEqual(BsonType.Array, _bsonReader.ReadBsonType());
Assert.AreEqual("a", _bsonReader.ReadName());
_bsonReader.ReadStartArray();
Assert.AreEqual(1, _bsonReader.ReadInt32());
Assert.AreEqual(2, _bsonReader.ReadInt32());
_bsonReader.ReadEndArray();
_bsonReader.ReadEndDocument();
Assert.AreEqual(BsonReaderState.Done, _bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize<BsonDocument>(json).ToJson());
}
public void TestDocumentOneElement()
{
var json = "{ \"x\" : 1 }";
using (_bsonReader = new JsonReader(json))
{
Assert.AreEqual(BsonType.Document, _bsonReader.ReadBsonType());
_bsonReader.ReadStartDocument();
Assert.AreEqual(BsonType.Int32, _bsonReader.ReadBsonType());
Assert.AreEqual("x", _bsonReader.ReadName());
Assert.AreEqual(1, _bsonReader.ReadInt32());
Assert.AreEqual(BsonType.EndOfDocument, _bsonReader.ReadBsonType());
_bsonReader.ReadEndDocument();
Assert.AreEqual(BsonReaderState.Done, _bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize<BsonDocument>(json).ToJson());
}
