static MongoBlockRepository()
{
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (var asm in assemblies)
{
foreach (var type in asm.ExportedTypes)
{
var attr = type.GetTypeInfo().GetCustomAttribute <InstructionTypeAttribute>();
if (attr != null)
{
BsonSerializer.RegisterDiscriminator(type, new BsonString(attr.TypeIdentifier));
//BsonSerializer.RegisterDiscriminator(type, TypeNameDiscriminator.GetDiscriminator(type));
//hack for dodgy mongo driver
IBsonWriter w = new BsonBinaryWriter(new MemoryStream());
var constr = type.GetConstructor(new Type[0]);
BsonSerializer.Serialize(w, type, constr.Invoke(null));
}
}
}
//BsonSerializer.RegisterDiscriminatorConvention(typeof(BlockTransaction), StandardDiscriminatorConvention.Scalar);
//TypeNameDiscriminator.GetDiscriminator
//TypeNameDiscriminator.
//BsonSerializer.RegisterDiscriminatorConvention(typeof(object), ObjectDiscriminatorConvention.Instance);
//BsonSerializer.RegisterDiscriminator(t, t.FullName));
}
private static void RegisterCustomDiscriminatorTypes(Type ClassType)
{
object[] regTypes = ClassType.GetCustomAttributes(typeof(MongoCustomDiscriminatorType), false);
foreach (object regType in regTypes)
{
if (regType != null)
{
var mongoCustomDiscriminatorType = (MongoCustomDiscriminatorType)regType;
BsonSerializer.RegisterDiscriminator(
mongoCustomDiscriminatorType.Type, mongoCustomDiscriminatorType.Type.Name);
}
}
}
/// <summary>
/// If the type is not registered, attach it to our discriminator
/// </summary>
/// <param name="actualType">the type to examine</param>
protected void RegisterNewTypesToDiscriminator(Type actualType)
{
// we've detected a new concrete type that isn't registered in MongoDB's serializer
if (actualType != typeof(object) && !actualType.GetTypeInfo().IsInterface&& !BsonSerializer.IsTypeDiscriminated(actualType))
{
try
{
BsonSerializer.RegisterDiscriminatorConvention(actualType, DiscriminatorConvention);
BsonSerializer.RegisterDiscriminator(actualType, DiscriminatorConvention.GetDiscriminator(typeof(object), actualType));
}
catch (BsonSerializationException)
{
// the MongoDB driver library has no nice mechanism for checking if a discriminator convention is registerd.
// The "Lookup" logic tends to define a default if it doesn't exist.
// So we're forced to eat the "duplicate registration" exception.
}
}
}
// static constructor
static BitmapSerializer()
{
BsonSerializer.RegisterDiscriminator(typeof(Bitmap), "Bitmap");
}
// from MongoDB.Bson.Serialization.BsonDefaultSerializationProvider.GetCollectionSerializer()
private IBsonSerializer GetCollectionSerializer(Type type)
{
Type implementedGenericDictionaryInterface = null;
Type implementedGenericEnumerableInterface = null;
Type implementedDictionaryInterface = null;
Type implementedEnumerableInterface = null;
var implementedInterfaces = new List <Type>(type.GetInterfaces());
if (type.IsInterface)
{
implementedInterfaces.Add(type);
}
foreach (var implementedInterface in implementedInterfaces)
{
if (implementedInterface.IsGenericType)
{
var genericInterfaceDefinition = implementedInterface.GetGenericTypeDefinition();
if (genericInterfaceDefinition == typeof(IDictionary <,>))
{
implementedGenericDictionaryInterface = implementedInterface;
}
if (genericInterfaceDefinition == typeof(IEnumerable <>))
{
implementedGenericEnumerableInterface = implementedInterface;
}
}
else
{
if (implementedInterface == typeof(IDictionary))
{
implementedDictionaryInterface = implementedInterface;
}
if (implementedInterface == typeof(IEnumerable))
{
implementedEnumerableInterface = implementedInterface;
}
}
}
// the order of the tests is important
if (implementedGenericDictionaryInterface != null)
{
var keyType = implementedGenericDictionaryInterface.GetGenericArguments()[0];
var valueType = implementedGenericDictionaryInterface.GetGenericArguments()[1];
//var genericSerializerDefinition = typeof(DictionarySerializer<,>);
var genericSerializerDefinition = BsonSerializer.LookupGenericSerializerDefinition(typeof(Dictionary <,>));
if (genericSerializerDefinition == null)
{
//throw new PBException("error missing generic dictionary serializer");
genericSerializerDefinition = typeof(DictionarySerializer <,>);
}
var genericSerializerType = genericSerializerDefinition.MakeGenericType(keyType, valueType);
return((IBsonSerializer)Activator.CreateInstance(genericSerializerType));
}
else if (implementedDictionaryInterface != null)
{
IBsonSerializer serializer = BsonSerializer.LookupSerializer(typeof(IDictionary));
if (serializer != null)
{
return(serializer);
}
return(new DictionarySerializer());
}
else if (implementedGenericEnumerableInterface != null)
{
var valueType = implementedGenericEnumerableInterface.GetGenericArguments()[0];
var readOnlyCollectionType = typeof(ReadOnlyCollection <>).MakeGenericType(valueType);
Type genericSerializerDefinition;
if (readOnlyCollectionType.IsAssignableFrom(type))
{
//genericSerializerDefinition = typeof(ReadOnlyCollectionSerializer<>);
genericSerializerDefinition = BsonSerializer.LookupGenericSerializerDefinition(typeof(ReadOnlyCollection <>));
if (genericSerializerDefinition == null)
{
genericSerializerDefinition = typeof(ReadOnlyCollectionSerializer <>);
}
if (type != readOnlyCollectionType)
{
BsonSerializer.RegisterDiscriminator(type, type.Name);
}
}
else
{
//genericSerializerDefinition = typeof(EnumerableSerializer<>);
genericSerializerDefinition = BsonSerializer.LookupGenericSerializerDefinition(typeof(IEnumerable <>));
if (genericSerializerDefinition == null)
{
genericSerializerDefinition = typeof(EnumerableSerializer <>);
}
}
var genericSerializerType = genericSerializerDefinition.MakeGenericType(valueType);
return((IBsonSerializer)Activator.CreateInstance(genericSerializerType));
}
else if (implementedEnumerableInterface != null)
{
IBsonSerializer serializer = BsonSerializer.LookupSerializer(typeof(IEnumerable));
if (serializer != null)
{
return(serializer);
}
return(new EnumerableSerializer());
}
return(null);
}
