/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { bsonWriter.WriteNull(); } else { var lazyBsonDocument = (LazyBsonDocument)value; var slice = lazyBsonDocument.Slice; if (slice == null) { BsonDocumentSerializer.Instance.Serialize(bsonWriter, typeof(BsonDocument), lazyBsonDocument, options); } else { using (var clonedSlice = slice.GetSlice(0, slice.Length)) { bsonWriter.WriteRawBsonDocument(clonedSlice); } } } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { throw new ArgumentNullException("value"); } bsonWriter.WriteUndefined(); }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { throw new ArgumentNullException("value"); } var bsonDateTime = (BsonDateTime)value; bsonWriter.WriteDateTime(bsonDateTime.MillisecondsSinceEpoch); }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { throw new ArgumentNullException("value"); } var objectId = ((BsonObjectId)value).Value; bsonWriter.WriteObjectId(objectId); }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { throw new ArgumentNullException("value"); } var timestamp = (BsonTimestamp)value; bsonWriter.WriteTimestamp(timestamp.Value); }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { throw new ArgumentNullException("value"); } var regex = (BsonRegularExpression)value; bsonWriter.WriteRegularExpression(regex); }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { throw new ArgumentNullException("value"); } var bsonBoolean = (BsonBoolean)value; bsonWriter.WriteBoolean(bsonBoolean.Value); }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { throw new ArgumentNullException("value"); } var script = (BsonJavaScript)value; bsonWriter.WriteJavaScript(script.Code); }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { throw new ArgumentNullException("value"); } var symbol = (BsonSymbol)value; bsonWriter.WriteSymbol(symbol.Name); }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { throw new ArgumentNullException("value"); } var bsonNull = (BsonNull)value; // check type by casting bsonWriter.WriteNull(); }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { throw new ArgumentNullException("value"); } var script = (BsonJavaScriptWithScope)value; bsonWriter.WriteJavaScriptWithScope(script.Code); BsonDocumentSerializer.Instance.Serialize(bsonWriter, typeof(BsonDocument), script.Scope, null); }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { throw new ArgumentNullException("value"); } var binaryData = (BsonBinaryData)value; var subType = binaryData.SubType; if (subType == BsonBinarySubType.UuidStandard || subType == BsonBinarySubType.UuidLegacy) { var writerGuidRepresentation = bsonWriter.Settings.GuidRepresentation; if (writerGuidRepresentation != GuidRepresentation.Unspecified) { var bytes = binaryData.Bytes; var guidRepresentation = binaryData.GuidRepresentation; if (guidRepresentation == GuidRepresentation.Unspecified) { var message = string.Format( "Cannot serialize BsonBinaryData with GuidRepresentation Unspecified to destination with GuidRepresentation {0}.", writerGuidRepresentation); throw new BsonSerializationException(message); } if (guidRepresentation != writerGuidRepresentation) { var guid = GuidConverter.FromBytes(bytes, guidRepresentation); bytes = GuidConverter.ToBytes(guid, writerGuidRepresentation); subType = (writerGuidRepresentation == GuidRepresentation.Standard) ? BsonBinarySubType.UuidStandard : BsonBinarySubType.UuidLegacy; guidRepresentation = writerGuidRepresentation; binaryData = new BsonBinaryData(bytes, subType, guidRepresentation); } } } bsonWriter.WriteBinaryData(binaryData); }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { bsonWriter.WriteNull(); } else { var rawBsonArray = (RawBsonArray)value; var slice = rawBsonArray.Slice; using (var clonedSlice = slice.GetSlice(0, slice.Length)) { bsonWriter.WriteRawBsonArray(clonedSlice); } } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { throw new ArgumentNullException("value"); } var wrapper = (BsonDocumentWrapper)value; var wrappedObject = wrapper.WrappedObject; var wrappedActualType = (wrappedObject == null) ? wrapper.WrappedNominalType : wrappedObject.GetType(); var serializer = (wrappedActualType == wrapper.WrappedNominalType) ? wrapper.Serializer : BsonSerializer.LookupSerializer(wrappedActualType); if (wrapper.IsUpdateDocument) { var savedCheckElementNames = bsonWriter.CheckElementNames; var savedCheckUpdateDocument = bsonWriter.CheckUpdateDocument; try { bsonWriter.CheckElementNames = false; bsonWriter.CheckUpdateDocument = true; serializer.Serialize(bsonWriter, wrapper.WrappedNominalType, wrapper.WrappedObject, wrapper.SerializationOptions); } finally { bsonWriter.CheckElementNames = savedCheckElementNames; bsonWriter.CheckUpdateDocument = savedCheckUpdateDocument; } } else { serializer.Serialize(bsonWriter, wrapper.WrappedNominalType, wrapper.WrappedObject, wrapper.SerializationOptions); } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var doubleValue = (double)value; var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options); switch (representationSerializationOptions.Representation) { case BsonType.Double: bsonWriter.WriteDouble(doubleValue); break; case BsonType.Int32: bsonWriter.WriteInt32(representationSerializationOptions.ToInt32(doubleValue)); break; case BsonType.Int64: bsonWriter.WriteInt64(representationSerializationOptions.ToInt64(doubleValue)); break; case BsonType.String: bsonWriter.WriteString(doubleValue.ToString("R", NumberFormatInfo.InvariantInfo)); break; default: var message = string.Format("'{0}' is not a valid Double representation.", representationSerializationOptions.Representation); throw new BsonSerializationException(message); } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { // note: the DateTime portion cannot be serialized as a BsonType.DateTime because it is NOT in UTC var dateTimeOffset = (DateTimeOffset)value; var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options); switch (representationSerializationOptions.Representation) { case BsonType.Array: bsonWriter.WriteStartArray(); bsonWriter.WriteInt64(dateTimeOffset.Ticks); bsonWriter.WriteInt32((int)dateTimeOffset.Offset.TotalMinutes); bsonWriter.WriteEndArray(); break; case BsonType.Document: bsonWriter.WriteStartDocument(); bsonWriter.WriteDateTime("DateTime", BsonUtils.ToMillisecondsSinceEpoch(dateTimeOffset.UtcDateTime)); bsonWriter.WriteInt64("Ticks", dateTimeOffset.Ticks); bsonWriter.WriteInt32("Offset", (int)dateTimeOffset.Offset.TotalMinutes); bsonWriter.WriteEndDocument(); break; case BsonType.String: bsonWriter.WriteString(XmlConvert.ToString(dateTimeOffset)); break; default: var message = string.Format("'{0}' is not a valid DateTimeOffset representation.", representationSerializationOptions.Representation); throw new BsonSerializationException(message); } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var objectId = (ObjectId)value; var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options); switch (representationSerializationOptions.Representation) { case BsonType.ObjectId: bsonWriter.WriteObjectId(objectId); break; case BsonType.String: bsonWriter.WriteString(objectId.ToString()); break; default: var message = string.Format("'{0}' is not a valid ObjectId representation.", representationSerializationOptions.Representation); throw new BsonSerializationException(message); } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { bsonWriter.WriteNull(); } else { var endPoint = (IPEndPoint)value; string stringValue; if (endPoint.AddressFamily == AddressFamily.InterNetwork) { stringValue = string.Format("{0}:{1}", endPoint.Address, endPoint.Port); // IPv4 } else { stringValue = string.Format("[{0}]:{1}", endPoint.Address, endPoint.Port); // IPv6 } bsonWriter.WriteString(stringValue); } }
#pragma warning restore 618 /// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { bsonWriter.WriteNull(); } else { var bytes = (byte[])value; var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options); switch (representationSerializationOptions.Representation) { case BsonType.Binary: bsonWriter.WriteBytes(bytes); break; case BsonType.String: var sb = new StringBuilder(bytes.Length * 2); for (int i = 0; i < bytes.Length; i++) { sb.Append(string.Format("{0:x2}", bytes[i])); } bsonWriter.WriteString(sb.ToString()); break; default: var message = string.Format("'{0}' is not a valid Byte[] representation.", representationSerializationOptions.Representation); throw new BsonSerializationException(message); } } }
/// <summary> /// Serializes an Image to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The Image.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (nominalType != typeof(Image)) { var message = string.Format("Nominal type must be Image, not {0}.", nominalType.FullName); throw new ArgumentException(message, "nominalType"); } if (value == null) { bsonWriter.WriteNull(); } else { var message = string.Format("Value must be null."); throw new ArgumentException(message, "value"); } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { bsonWriter.WriteNull(); } else { var actualType = value.GetType(); if (actualType != typeof(object)) { var message = string.Format("ObjectSerializer can only be used with type System.Object, not type {0}.", actualType.FullName); throw new InvalidOperationException(message); } bsonWriter.WriteStartDocument(); bsonWriter.WriteEndDocument(); } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var int64Value = (long)value; var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options); switch (representationSerializationOptions.Representation) { case BsonType.Double: bsonWriter.WriteDouble(representationSerializationOptions.ToDouble(int64Value)); break; case BsonType.Int32: bsonWriter.WriteInt32(representationSerializationOptions.ToInt32(int64Value)); break; case BsonType.Int64: bsonWriter.WriteInt64(int64Value); break; case BsonType.String: bsonWriter.WriteString(XmlConvert.ToString(int64Value)); break; default: var message = string.Format("'{0}' is not a valid Int64 representation.", representationSerializationOptions.Representation); throw new BsonSerializationException(message); } }
/// <summary> /// Serializes a Bitmap to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The Bitmap.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (nominalType != typeof(Image) && nominalType != typeof(Bitmap)) { var message = string.Format("Nominal type must be Image or Bitmap, not {0}.", nominalType.FullName); throw new ArgumentException(message, "nominalType"); } if (value == null) { bsonWriter.WriteNull(); } else { var actualType = value.GetType(); if (actualType != typeof(Bitmap)) { var message = string.Format("Actual type must be Bitmap, not {0}.", actualType.FullName); throw new ArgumentException(message, "actualType"); } var bitmap = (Bitmap)value; var stream = new MemoryStream(); bitmap.Save(stream, ImageFormat.Bmp); var bytes = stream.ToArray(); if (nominalType == typeof(Image)) { bsonWriter.WriteStartDocument(); bsonWriter.WriteString("_t", "Bitmap"); bsonWriter.WriteBinaryData("bitmap", bytes, BsonBinarySubType.Binary); bsonWriter.WriteEndDocument(); } else { bsonWriter.WriteBinaryData(bytes, BsonBinarySubType.Binary); } } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { bsonWriter.WriteNull(); } else { if (nominalType == typeof(object)) { var actualType = value.GetType(); bsonWriter.WriteStartDocument(); bsonWriter.WriteString("_t", TypeNameDiscriminator.GetDiscriminator(actualType)); bsonWriter.WriteName("_v"); Serialize(bsonWriter, actualType, value, options); // recursive call replacing nominalType with actualType bsonWriter.WriteEndDocument(); return; } var dictionary = (IDictionary)value; var dictionarySerializationOptions = EnsureSerializationOptions(options); var dictionaryRepresentation = dictionarySerializationOptions.Representation; var keyValuePairSerializationOptions = dictionarySerializationOptions.KeyValuePairSerializationOptions; if (dictionaryRepresentation == DictionaryRepresentation.Dynamic) { dictionaryRepresentation = DictionaryRepresentation.Document; foreach (object key in dictionary.Keys) { var name = key as string; // check for null and type string at the same time if (name == null || name[0] == '$' || name.IndexOf('.') != -1) { dictionaryRepresentation = DictionaryRepresentation.ArrayOfArrays; break; } } } switch (dictionaryRepresentation) { case DictionaryRepresentation.Document: bsonWriter.WriteStartDocument(); foreach (DictionaryEntry dictionaryEntry in dictionary) { bsonWriter.WriteName((string)dictionaryEntry.Key); BsonSerializer.Serialize(bsonWriter, typeof(object), dictionaryEntry.Value, keyValuePairSerializationOptions.ValueSerializationOptions); } bsonWriter.WriteEndDocument(); break; case DictionaryRepresentation.ArrayOfArrays: case DictionaryRepresentation.ArrayOfDocuments: // override KeyValuePair representation if necessary var keyValuePairRepresentation = (dictionaryRepresentation == DictionaryRepresentation.ArrayOfArrays) ? BsonType.Array : BsonType.Document; if (keyValuePairSerializationOptions.Representation != keyValuePairRepresentation) { keyValuePairSerializationOptions = new KeyValuePairSerializationOptions( keyValuePairRepresentation, keyValuePairSerializationOptions.KeySerializationOptions, keyValuePairSerializationOptions.ValueSerializationOptions); } bsonWriter.WriteStartArray(); foreach (DictionaryEntry dictionaryEntry in dictionary) { var keyValuePair = new KeyValuePair<object, object>(dictionaryEntry.Key, dictionaryEntry.Value); _keyValuePairSerializer.Serialize( bsonWriter, typeof(KeyValuePair<object, object>), keyValuePair, keyValuePairSerializationOptions); } bsonWriter.WriteEndArray(); break; default: var message = string.Format("'{0}' is not a valid IDictionary representation.", dictionaryRepresentation); throw new BsonSerializationException(message); } } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { bsonWriter.WriteStartDocument(); bsonWriter.WriteBoolean("_csharpnull", true); bsonWriter.WriteEndDocument(); } else { BsonValueSerializer.Instance.Serialize(bsonWriter, nominalType, value, options); } }
// protected methods /// <summary> /// Serializes the result of the builder to a BsonWriter. /// </summary> /// <param name="bsonWriter">The writer.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="options">The serialization options.</param> protected abstract void Serialize( BsonWriter bsonWriter, Type nominalType, IBsonSerializationOptions options);
void IBsonSerializable.Serialize(BsonWriter bsonWriter, Type nominalType, IBsonSerializationOptions options) { Serialize(bsonWriter, nominalType, options); }
public void Serialize(BsonWriter bsonWriter, Type nominalType, IBsonSerializationOptions options) { BsonSerializer.Serialize(bsonWriter, _nominalType, _obj, options); // use wrapped nominalType }
/// <summary> /// Serializes a document to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The document.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (!nominalType.IsInterface) { var message = string.Format("Nominal type must be an interface, not {0}.", nominalType.FullName); throw new ArgumentException(message, "nominalType"); } if (value == null) { bsonWriter.WriteNull(); } else { var actualType = value.GetType(); var serializer = BsonSerializer.LookupSerializer(actualType); serializer.Serialize(bsonWriter, nominalType, value, options); } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var decimalValue = (Decimal)value; var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options); switch (representationSerializationOptions.Representation) { case BsonType.Array: bsonWriter.WriteStartArray(); var bits = Decimal.GetBits(decimalValue); bsonWriter.WriteInt32(bits[0]); bsonWriter.WriteInt32(bits[1]); bsonWriter.WriteInt32(bits[2]); bsonWriter.WriteInt32(bits[3]); bsonWriter.WriteEndArray(); break; case BsonType.Double: bsonWriter.WriteDouble(representationSerializationOptions.ToDouble(decimalValue)); break; case BsonType.Int32: bsonWriter.WriteInt32(representationSerializationOptions.ToInt32(decimalValue)); break; case BsonType.Int64: bsonWriter.WriteInt64(representationSerializationOptions.ToInt64(decimalValue)); break; case BsonType.String: bsonWriter.WriteString(XmlConvert.ToString(decimalValue)); break; default: var message = string.Format("'{0}' is not a valid Decimal representation.", representationSerializationOptions.Representation); throw new BsonSerializationException(message); } }