| public abstract WriteBinaryData ( BsonBinaryData binaryData ) : void | ||
| binaryData | BsonBinaryData | The binary data. |
| return | void | |
#pragma warning restore 618
public override void Serialize(
BsonWriter bsonWriter,
Type nominalType,
object value,
bool serializeIdFirst
) {
if (value == null) {
bsonWriter.WriteNull();
} else {
bsonWriter.WriteBinaryData((byte[]) value, BsonBinarySubType.Binary);
}
}
public void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
var underlyingValue = value.GetType().GetProperty("Value").GetValue(value, null);
var underlyingValueType = nominalType.GetConceptValueType();
if (underlyingValueType == typeof(Guid)) {
var guid = (Guid)underlyingValue;
var guidAsBytes = guid.ToByteArray ();
bsonWriter.WriteBinaryData (guidAsBytes, BsonBinarySubType.UuidLegacy, GuidRepresentation.CSharpLegacy);
} else if (underlyingValueType == typeof(double))
bsonWriter.WriteDouble ((double)underlyingValue);
else if (underlyingValueType == typeof(float))
bsonWriter.WriteDouble ((double)underlyingValue);
else if (underlyingValueType == typeof(Int32))
bsonWriter.WriteInt32 ((Int32)underlyingValue);
else if (underlyingValueType == typeof(Int64))
bsonWriter.WriteInt64 ((Int64)underlyingValue);
else if (underlyingValueType == typeof(bool))
bsonWriter.WriteBoolean ((bool)underlyingValue);
else if (underlyingValueType == typeof(string))
bsonWriter.WriteString ((string)(underlyingValue ?? string.Empty));
else if (underlyingValueType == typeof(decimal))
bsonWriter.WriteString (underlyingValue.ToString());
}
/// <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 guid = (Guid)value;
var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options);
switch (representationSerializationOptions.Representation)
{
case BsonType.Binary:
var writerGuidRepresentation = bsonWriter.Settings.GuidRepresentation;
if (writerGuidRepresentation == GuidRepresentation.Unspecified)
{
throw new BsonSerializationException("GuidSerializer cannot serialize a Guid when GuidRepresentation is Unspecified.");
}
var bytes = GuidConverter.ToBytes(guid, writerGuidRepresentation);
var subType = (writerGuidRepresentation == GuidRepresentation.Standard) ? BsonBinarySubType.UuidStandard : BsonBinarySubType.UuidLegacy;
bsonWriter.WriteBinaryData(bytes, subType, writerGuidRepresentation);
break;
case BsonType.String:
bsonWriter.WriteString(guid.ToString());
break;
default:
var message = string.Format("'{0}' is not a valid Guid representation.", representationSerializationOptions.Representation);
throw new BsonSerializationException(message);
}
}
#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 bitArray = (BitArray)value;
var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options);
switch (representationSerializationOptions.Representation)
{
case BsonType.Binary:
if ((bitArray.Length % 8) == 0)
{
bsonWriter.WriteBinaryData(GetBytes(bitArray), BsonBinarySubType.Binary);
}
else
{
bsonWriter.WriteStartDocument();
bsonWriter.WriteInt32("Length", bitArray.Length);
bsonWriter.WriteBinaryData("Bytes", GetBytes(bitArray), BsonBinarySubType.Binary);
bsonWriter.WriteEndDocument();
}
break;
case BsonType.String:
var sb = new StringBuilder(bitArray.Length);
for (int i = 0; i < bitArray.Length; i++)
{
sb.Append(bitArray[i] ? '1' : '0');
}
bsonWriter.WriteString(sb.ToString());
break;
default:
var message = string.Format("'{0}' is not a valid BitArray 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 binaryData = (BsonBinaryData) value;
var bytes = binaryData.Bytes;
var subType = binaryData.SubType;
var guidRepresentation = binaryData.GuidRepresentation;
if (subType == BsonBinarySubType.UuidStandard || subType == BsonBinarySubType.UuidLegacy) {
var writerGuidRepresentation = bsonWriter.Settings.GuidRepresentation;
if (writerGuidRepresentation != GuidRepresentation.Unspecified) {
if (guidRepresentation == GuidRepresentation.Unspecified) {
var message = string.Format("Cannot serialize BsonBinaryData with GuidRepresentation Unspecified to destination with GuidRepresentation {1}.", 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;
}
}
}
bsonWriter.WriteBinaryData(bytes, subType, guidRepresentation);
}
}
/// <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)
{
var byteValue = (byte)value;
var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options);
switch (representationSerializationOptions.Representation)
{
case BsonType.Binary:
bsonWriter.WriteBinaryData(new byte[] { byteValue }, BsonBinarySubType.Binary);
break;
case BsonType.Int32:
bsonWriter.WriteInt32(byteValue);
break;
case BsonType.Int64:
bsonWriter.WriteInt64(byteValue);
break;
case BsonType.String:
bsonWriter.WriteString(string.Format("{0:x2}", byteValue));
break;
default:
var message = string.Format("'{0}' is not a valid Byte representation.", representationSerializationOptions.Representation);
throw new BsonSerializationException(message);
}
}
#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.WriteBinaryData(bytes, BsonBinarySubType.Binary);
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);
}
}
}
public override void Serialize(
BsonWriter bsonWriter,
Type nominalType,
object value,
bool serializeIdFirst
)
{
var guid = (Guid) value;
bsonWriter.WriteBinaryData(guid.ToByteArray(), BsonBinarySubType.Uuid);
}
public override void Serialize(
BsonWriter bsonWriter,
Type nominalType,
object value,
IBsonSerializationOptions options
) {
var sbyteValue = (sbyte) value;
var representation = (options == null) ? BsonType.Int32 : ((RepresentationSerializationOptions) options).Representation;
switch (representation) {
case BsonType.Binary:
bsonWriter.WriteBinaryData(new byte[] { (byte) sbyteValue }, BsonBinarySubType.Binary);
break;
case BsonType.Int32:
bsonWriter.WriteInt32(sbyteValue);
break;
case BsonType.Int64:
bsonWriter.WriteInt64(sbyteValue);
break;
case BsonType.String:
bsonWriter.WriteString(string.Format("{0:x2}", sbyteValue));
break;
default:
var message = string.Format("'{0}' is not a valid representation for type 'Byte'", representation);
throw new BsonSerializationException(message);
}
}
public override void Serialize(
BsonWriter bsonWriter,
Type nominalType,
object value,
IBsonSerializationOptions options
)
{
if (value == null) {
bsonWriter.WriteNull();
} else {
var binaryData = (BsonBinaryData) value;
bsonWriter.WriteBinaryData(binaryData.Bytes, binaryData.SubType);
}
}
#pragma warning restore 618
public override void Serialize(
BsonWriter bsonWriter,
Type nominalType,
object value,
bool serializeIdFirst
) {
if (value == null) {
bsonWriter.WriteNull();
} else {
var bitArray = (BitArray) value;
if ((bitArray.Length % 8) == 0) {
bsonWriter.WriteBinaryData(GetBytes(bitArray), BsonBinarySubType.Binary);
} else {
bsonWriter.WriteStartDocument();
bsonWriter.WriteInt32("Length", bitArray.Length);
bsonWriter.WriteBinaryData("Bytes", GetBytes(bitArray), BsonBinarySubType.Binary);
bsonWriter.WriteEndDocument();
}
}
}
void IBsonSerializable.Serialize(
BsonWriter bsonWriter,
Type nominalType,
IBsonSerializationOptions options
)
{
bsonWriter.WriteStartDocument();
bsonWriter.WriteString("$ref", collectionName);
if (id is ObjectId) {
var objectId = (ObjectId) id;
bsonWriter.WriteObjectId("$id", objectId.Timestamp, objectId.Machine, objectId.Pid, objectId.Increment);
} else if (id is Guid) {
var guid = (Guid) id;
bsonWriter.WriteBinaryData("$id", guid.ToByteArray(), BsonBinarySubType.Uuid);
} else if (id is int) {
bsonWriter.WriteInt32("$id", (int) id);
} else if (id is long) {
bsonWriter.WriteInt64("$id", (long) id);
} else if (id is string) {
bsonWriter.WriteString("$id", (string) id);
} else {
var message = string.Format("Unexpected Id type: {0}", id.GetType().FullName);
throw new BsonInternalException(message);
}
if (databaseName != null) {
bsonWriter.WriteString("$db", databaseName);
}
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 guid = (Guid) value;
var guidSerializationOptions = options as GuidSerializationOptions;
if (guidSerializationOptions == null) {
var representationOptions = options as RepresentationSerializationOptions;
if (representationOptions != null) {
guidSerializationOptions = new GuidSerializationOptions(representationOptions.Representation);
}
}
if (guidSerializationOptions == null) {
guidSerializationOptions = GuidSerializationOptions.Defaults;
}
switch (guidSerializationOptions.Representation) {
case BsonType.Binary:
var bytes = guid.ToByteArray();
if (guidSerializationOptions.ByteOrder == GuidByteOrder.BigEndian && BitConverter.IsLittleEndian) {
bytes = (byte[]) bytes.Clone(); // Clone is defensive in case Guid.ToByteArray returns an internal copy
Array.Reverse(bytes, 0, 4);
Array.Reverse(bytes, 4, 2);
Array.Reverse(bytes, 6, 2);
}
bsonWriter.WriteBinaryData(bytes, BsonBinarySubType.Uuid);
break;
case BsonType.String:
bsonWriter.WriteString(guid.ToString());
break;
default:
var message = string.Format("'{0}' is not a valid representation for type 'Guid'", guidSerializationOptions.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 guid = (Guid) value;
var representation = (options == null) ? BsonType.Binary : ((RepresentationSerializationOptions) options).Representation;
switch (representation) {
case BsonType.Binary:
bsonWriter.WriteBinaryData(guid.ToByteArray(), BsonBinarySubType.Uuid);
break;
case BsonType.String:
bsonWriter.WriteString(guid.ToString());
break;
default:
var message = string.Format("'{0}' is not a valid representation for type 'Guid'", representation);
throw new BsonSerializationException(message);
}
}
public override void Serialize(
BsonWriter bsonWriter,
Type nominalType,
object value,
bool serializeIdFirst
)
{
var guid = (Guid) value;
switch (representation) {
case BsonType.Binary:
bsonWriter.WriteBinaryData(guid.ToByteArray(), BsonBinarySubType.Uuid);
break;
case BsonType.String:
bsonWriter.WriteString(guid.ToString());
break;
default:
throw new BsonInternalException("Unexpected representation");
}
}