/// <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);
}
}