/// <summary>
/// Gets the serializer.
/// </summary>
/// <returns>The serializer.</returns>
public IBsonSerializer GetSerializer()
{
if (_serializer == null)
{
// return special serializer for BsonValue members that handles the _csharpnull representation
if (_memberTypeIsBsonValue)
{
var wrappedSerializer = BsonSerializer.LookupSerializer(_memberType);
var isBsonArraySerializer = wrappedSerializer is IBsonArraySerializer;
var isBsonDocumentSerializer = wrappedSerializer is IBsonDocumentSerializer;
Type csharpNullSerializerDefinition;
if (isBsonArraySerializer && isBsonDocumentSerializer)
{
csharpNullSerializerDefinition = typeof(BsonValueCSharpNullArrayAndDocumentSerializer <>);
}
else if (isBsonArraySerializer)
{
csharpNullSerializerDefinition = typeof(BsonValueCSharpNullArraySerializer <>);
}
else if (isBsonDocumentSerializer)
{
csharpNullSerializerDefinition = typeof(BsonValueCSharpNullDocumentSerializer <>);
}
else
{
csharpNullSerializerDefinition = typeof(BsonValueCSharpNullSerializer <>);
}
var csharpNullSerializerType = csharpNullSerializerDefinition.MakeGenericType(_memberType);
var csharpNullSerializer = (IBsonSerializer)Activator.CreateInstance(csharpNullSerializerType, wrappedSerializer);
_serializer = csharpNullSerializer;
}
else
{
_serializer = BsonSerializer.LookupSerializer(_memberType);
}
}
return(_serializer);
}
/// <summary>
/// Serializes a value.
/// </summary>
/// <param name="context">The serialization context.</param>
/// <param name="args">The serialization args.</param>
/// <param name="value">The object.</param>
public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, TClass value)
{
var bsonWriter = context.Writer;
if (value == null)
{
bsonWriter.WriteNull();
}
else
{
var actualType = value.GetType();
if (actualType == typeof(TClass))
{
SerializeClass(context, args, value);
}
else
{
var serializer = BsonSerializer.LookupSerializer(actualType);
serializer.Serialize(context, args, value);
}
}
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public object Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options)
{
VerifyNominalType(nominalType);
if (bsonReader.GetCurrentBsonType() == Bson.BsonType.Null)
{
bsonReader.ReadNull();
return(null);
}
else
{
var discriminatorConvention = _classMap.GetDiscriminatorConvention();
var actualType = discriminatorConvention.GetActualType(bsonReader, nominalType);
if (actualType != nominalType)
{
var serializer = BsonSerializer.LookupSerializer(actualType);
if (serializer != this)
{
return(serializer.Deserialize(bsonReader, nominalType, actualType, options));
}
}
return(Deserialize(bsonReader, nominalType, actualType, options));
}
}
// public methods
/// <summary>
/// Deserializes a value.
/// </summary>
/// <param name="context">The deserialization context.</param>
/// <returns>An object.</returns>
public override TClass Deserialize(BsonDeserializationContext context)
{
var bsonReader = context.Reader;
if (_classMap.ClassType.IsValueType)
{
var message = string.Format("Value class {0} cannot be deserialized.", _classMap.ClassType.FullName);
throw new BsonSerializationException(message);
}
if (_classMap.IsAnonymous)
{
throw new InvalidOperationException("An anonymous class cannot be deserialized.");
}
if (bsonReader.GetCurrentBsonType() == Bson.BsonType.Null)
{
bsonReader.ReadNull();
return(default(TClass));
}
else
{
var discriminatorConvention = _classMap.GetDiscriminatorConvention();
var actualType = discriminatorConvention.GetActualType(bsonReader, context.NominalType);
if (actualType == typeof(TClass))
{
return(DeserializeClass(context));
}
else
{
var serializer = BsonSerializer.LookupSerializer(actualType);
return((TClass)serializer.Deserialize(context));
}
}
}
/// <summary>
/// Gets the serializer for the specified <typeparamref name="T" />.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns>
/// The serializer.
/// </returns>
public IBsonSerializer <T> GetSerializer <T>()
{
return(BsonSerializer.LookupSerializer <T>());
}
// public methods
/// <summary>
/// Gets the serializer for the specified <paramref name="type" />.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>
/// The serializer.
/// </returns>
public IBsonSerializer GetSerializer(Type type)
{
return(BsonSerializer.LookupSerializer(type));
}