| public abstract WriteString ( string value ) : void | ||
| value | string | The String value. |
| return | void | |
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
if (value == null)
throw new PBException("serialize OXmlSimpleFieldElement value is null");
if (_trace)
pb.Trace.WriteLine("OXmlSimpleFieldElementSerializer.Serialize()");
OXmlSimpleFieldElement element = (OXmlSimpleFieldElement)value;
bsonWriter.WriteStartDocument();
bsonWriter.WriteString("Type", "SimpleField");
bsonWriter.WriteString("Instruction", element.Instruction);
bsonWriter.WriteEndDocument();
}
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
if (value == null)
throw new PBException("serialize OXmlOpenHeader value is null");
if (_trace)
pb.Trace.WriteLine("OXmlOpenHeaderElementSerializer.Serialize()");
OXmlOpenHeaderElement element = (OXmlOpenHeaderElement)value;
bsonWriter.WriteStartDocument();
bsonWriter.WriteString("Type", "OpenHeader");
bsonWriter.WriteString("HeaderType", element.HeaderType.ToString());
bsonWriter.WriteEndDocument();
}
public void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
var method = (MethodInfo)value;
bsonWriter.WriteStartDocument();
bsonWriter.WriteName("Type");
bsonWriter.WriteString(method.DeclaringType.AssemblyQualifiedName);
bsonWriter.WriteName("Method");
bsonWriter.WriteString(GetMethodSignature(method));
bsonWriter.WriteEndDocument();
}
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
if (value == null)
throw new PBException("serialize OXmlParagraphElement value is null");
if (_trace)
pb.Trace.WriteLine("OXmlParagraphElementSerializer.Serialize()");
OXmlParagraphElement paragraph = (OXmlParagraphElement)value;
bsonWriter.WriteStartDocument();
bsonWriter.WriteString("Type", "Paragraph");
if (paragraph.Style != null)
bsonWriter.WriteString("Style", paragraph.Style);
bsonWriter.WriteEndDocument();
}
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
if (value == null)
throw new PBException("serialize OXmlTextElement value is null");
if (_trace)
pb.Trace.WriteLine("OXmlTextElementSerializer.Serialize()");
OXmlTextElement element = (OXmlTextElement)value;
bsonWriter.WriteStartDocument();
bsonWriter.WriteString("Type", "Text");
if (element.Text != null)
bsonWriter.WriteString("Text", element.Text);
if (element.PreserveSpace)
bsonWriter.WriteBoolean("PreserveSpace", element.PreserveSpace);
bsonWriter.WriteEndDocument();
}
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
var c = (C)value;
bsonWriter.WriteStartDocument();
bsonWriter.WriteString("nominalType", nominalType.Name);
bsonWriter.WriteInt32("X", c.X);
bsonWriter.WriteEndDocument();
}
public override void Serialize(
BsonWriter bsonWriter,
Type nominalType,
object value,
IBsonSerializationOptions options
) {
var dateTime = (DateTime) value;
bsonWriter.WriteString(dateTime.ToString("yyyy-MM-dd"));
}
public override void Serialize(
BsonWriter bsonWriter,
Type nominalType,
object value,
IBsonSerializationOptions options
)
{
var type = (Type)value;
bsonWriter.WriteString(type.AssemblyQualifiedName);
}
public override void Serialize(BsonWriter bsonWriter, Type nominalType,
object value, IBsonSerializationOptions options)
{
if (value != null)
{
bsonWriter.WriteString(value.ToString());
}
else
{
bsonWriter.WriteNull();
}
}
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
if (value == null)
{
bsonWriter.WriteNull();
}
else
{
var crs = (GeoJsonLinkedCoordinateReferenceSystem)value;
bsonWriter.WriteStartDocument();
SerializeType(bsonWriter, crs.Type);
bsonWriter.WriteStartDocument("properties");
bsonWriter.WriteString("href", crs.HRef);
if (crs.HRefType != null)
{
bsonWriter.WriteString("type", crs.HRefType);
}
bsonWriter.WriteEndDocument();
bsonWriter.WriteEndDocument();
}
}
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
// when entry is null, do not throw, just write null
if (value == null)
{
bsonWriter.WriteNull();
return;
}
if (_failOnSerialize)
throw new InvalidOperationException();
bsonWriter.WriteString((string)value);
}
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
if (value == null)
{
throw new PBException("error serialize UrlImage value is null");
}
//bsonWriter.WriteString(((WebImage)value).Url);
string url = ((WebImage)value).Url;
if (url != null)
bsonWriter.WriteString(url);
else
bsonWriter.WriteNull();
}
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
var identity = (Identity)value;
var objectId = new ObjectId(identity.ToArray());
BsonType bsonType = options == null ? BsonType.ObjectId : ((RepresentationSerializationOptions)options).Representation;
switch (bsonType)
{
case BsonType.String:
bsonWriter.WriteString(objectId.ToString());
break;
case BsonType.ObjectId:
bsonWriter.WriteObjectId(objectId.Timestamp, objectId.Machine, objectId.Pid, objectId.Increment);
break;
default:
throw new BsonSerializationException(string.Format("'{0}' is not a valid representation for type 'Identity'", bsonType));
}
}
public override void Serialize(
BsonWriter bsonWriter,
Type nominalType,
object value,
IBsonSerializationOptions options
)
{
var nvc = (NameValueCollection)value;
bsonWriter.WriteStartDocument();
if (nvc != null && nvc.Count > 0)
{
foreach (var key in nvc.AllKeys)
{
bsonWriter.WriteString(key.Replace(".", "__period__"), nvc[key]);
}
}
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)
{
if (_trace)
pb.Trace.WriteLine("ZStringSerializer.Serialize()");
if (value == null)
{
//throw new ArgumentNullException("value");
throw new PBException("error serialize ZString value is null");
}
string stringValue = ((ZString)value).Value;
if (stringValue == null)
bsonWriter.WriteNull();
else
bsonWriter.WriteString(stringValue);
}
public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options )
{
var dictionary = (DynamicDictionary)value;
bsonWriter.WriteStartDocument();
bsonWriter.WriteString( "_t", "DynamicDictionary" );
if( dictionary != null )
{
foreach( var entry in dictionary )
{
bsonWriter.WriteName( entry.Key.Replace( '.', '\x03' ) );
BsonSerializer.Serialize( bsonWriter, typeof( object ), entry.Value );
}
}
bsonWriter.WriteEndDocument();
}
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
if (value == null)
throw new PBException("serialize OXmlDocDefaultsRunPropertiesElement value is null");
if (_trace)
pb.Trace.WriteLine("OXmlRunPropertiesDefaultElementSerializer.Serialize()");
OXmlDocDefaultsRunPropertiesElement element = (OXmlDocDefaultsRunPropertiesElement)value;
bsonWriter.WriteStartDocument();
bsonWriter.WriteString("Type", "DocDefaultsRunProperties");
if (element.RunFonts != null)
{
bsonWriter.WriteStartDocument("RunFonts");
OXmlCommonSerializer.WriteRunFonts(bsonWriter, element.RunFonts);
bsonWriter.WriteEndDocument();
}
if (element.FontSize != null)
bsonWriter.WriteString("FontSize", element.FontSize);
bsonWriter.WriteEndDocument();
}
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
if (_trace)
pb.Trace.WriteLine("ZStringArraySerializer.Serialize()");
if (value == null)
{
throw new PBException("error serialize ZStringArray value is null");
}
string[] stringValues = ((ZStringArray)value).Values;
if (stringValues == null)
bsonWriter.WriteNull();
else
{
bsonWriter.WriteStartArray();
foreach (string stringValue in stringValues)
{
bsonWriter.WriteString(stringValue);
}
bsonWriter.WriteEndArray();
}
}
/// <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)
{
var timeSpan = (TimeSpan)value;
// support RepresentationSerializationOptions for backward compatibility
var representationSerializationOptions = options as RepresentationSerializationOptions;
if (representationSerializationOptions != null)
{
options = new TimeSpanSerializationOptions(representationSerializationOptions.Representation);
}
var timeSpanSerializationOptions = EnsureSerializationOptions<TimeSpanSerializationOptions>(options);
switch (timeSpanSerializationOptions.Representation)
{
case BsonType.Double:
bsonWriter.WriteDouble(ToDouble(timeSpan, timeSpanSerializationOptions.Units));
break;
case BsonType.Int32:
bsonWriter.WriteInt32(ToInt32(timeSpan, timeSpanSerializationOptions.Units));
break;
case BsonType.Int64:
bsonWriter.WriteInt64(ToInt64(timeSpan, timeSpanSerializationOptions.Units));
break;
case BsonType.String:
bsonWriter.WriteString(timeSpan.ToString()); // not XmlConvert.ToString (we're using .NET's format for TimeSpan)
break;
default:
var message = string.Format("'{0}' is not a valid TimeSpan representation.", timeSpanSerializationOptions.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 int16Value = (short)value;
var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options);
switch (representationSerializationOptions.Representation)
{
case BsonType.Double:
bsonWriter.WriteDouble(representationSerializationOptions.ToDouble(int16Value));
break;
case BsonType.Int32:
bsonWriter.WriteInt32(representationSerializationOptions.ToInt32(int16Value));
break;
case BsonType.Int64:
bsonWriter.WriteInt64(representationSerializationOptions.ToInt64(int16Value));
break;
case BsonType.String:
bsonWriter.WriteString(XmlConvert.ToString(int16Value));
break;
default:
var message = string.Format("'{0}' is not a valid Int16 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 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);
}
}
/// <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.Timestamp, objectId.Machine, objectId.Pid, objectId.Increment);
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 stringValue = (string)value;
var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options);
switch (representationSerializationOptions.Representation)
{
case BsonType.ObjectId:
var id = ObjectId.Parse(stringValue);
bsonWriter.WriteObjectId(id.Timestamp, id.Machine, id.Pid, id.Increment);
break;
case BsonType.String:
bsonWriter.WriteString(stringValue);
break;
case BsonType.Symbol:
bsonWriter.WriteSymbol(stringValue);
break;
default:
var message = string.Format("'{0}' is not a valid String 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 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);
}
}
/// <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 dateTime = (DateTime)value;
var dateTimeSerializationOptions = EnsureSerializationOptions<DateTimeSerializationOptions>(options);
DateTime utcDateTime;
if (dateTimeSerializationOptions.DateOnly)
{
if (dateTime.TimeOfDay != TimeSpan.Zero)
{
throw new BsonSerializationException("TimeOfDay component is not zero.");
}
utcDateTime = DateTime.SpecifyKind(dateTime, DateTimeKind.Utc); // not ToLocalTime
}
else
{
utcDateTime = BsonUtils.ToUniversalTime(dateTime);
}
var millisecondsSinceEpoch = BsonUtils.ToMillisecondsSinceEpoch(utcDateTime);
switch (dateTimeSerializationOptions.Representation)
{
case BsonType.DateTime:
bsonWriter.WriteDateTime(millisecondsSinceEpoch);
break;
case BsonType.Document:
bsonWriter.WriteStartDocument();
bsonWriter.WriteDateTime("DateTime", millisecondsSinceEpoch);
bsonWriter.WriteInt64("Ticks", utcDateTime.Ticks);
bsonWriter.WriteEndDocument();
break;
case BsonType.Int64:
bsonWriter.WriteInt64(utcDateTime.Ticks);
break;
case BsonType.String:
if (dateTimeSerializationOptions.DateOnly)
{
bsonWriter.WriteString(dateTime.ToString("yyyy-MM-dd"));
}
else
{
// we're not using XmlConvert.ToString because of bugs in Mono
if (dateTime == DateTime.MinValue || dateTime == DateTime.MaxValue)
{
// serialize MinValue and MaxValue as Unspecified so we do NOT get the time zone offset
dateTime = DateTime.SpecifyKind(dateTime, DateTimeKind.Unspecified);
}
else if (dateTime.Kind == DateTimeKind.Unspecified)
{
// serialize Unspecified as Local se we get the time zone offset
dateTime = DateTime.SpecifyKind(dateTime, DateTimeKind.Local);
}
bsonWriter.WriteString(dateTime.ToString("yyyy-MM-ddTHH:mm:ss.FFFFFFFK"));
}
break;
default:
var message = string.Format("'{0}' is not a valid DateTime representation.", dateTimeSerializationOptions.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 boolValue = (bool)value;
var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options);
switch (representationSerializationOptions.Representation)
{
case BsonType.Boolean:
bsonWriter.WriteBoolean(boolValue);
break;
case BsonType.Double:
bsonWriter.WriteDouble(boolValue ? 1.0 : 0.0);
break;
case BsonType.Int32:
bsonWriter.WriteInt32(boolValue ? 1 : 0);
break;
case BsonType.Int64:
bsonWriter.WriteInt64(boolValue ? 1 : 0);
break;
case BsonType.String:
bsonWriter.WriteString(XmlConvert.ToString(boolValue));
break;
default:
var message = string.Format("'{0}' is not a valid Boolean 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);
}
}
}
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
var version = (MigrationVersion) value;
var versionString = string.Format("{0}.{1}.{2}", version.Major, version.Minor, version.Revision);
bsonWriter.WriteString(versionString);
}