public static IServiceCollection AddMongoDataAccess(this IServiceCollection services, IConfiguration configuration) { IConfigurationSection dataAccessConfig = configuration.GetSection("DataAccess"); string connectionString = dataAccessConfig.GetValue <string>("ConnectionString"); services.AddHangfire(x => x.UseMongoStorage(connectionString, DbNames.Jobs)); BsonSerializer.RegisterDiscriminatorConvention(typeof(Project), new HierarchicalDiscriminatorConvention("appName")); var pack = new ConventionPack { new CamelCaseElementNameConvention(), new ObjectRefConvention() }; ConventionRegistry.Register("Custom", pack, t => true); services.AddSingleton <IMongoClient>(sp => new MongoClient(connectionString)); services.AddMongoRepository <SendReceiveJob>("send_receive"); services.AddMongoRepository <User>("users", cm => { cm.MapMember(u => u.SiteRole).SetSerializer( new DictionaryInterfaceImplementerSerializer <Dictionary <string, string> >( DictionaryRepresentation.Document, new SiteDomainSerializer(), new StringSerializer())); }); services.AddMongoRepository <Project>("projects"); services.AddMongoRepository <LexProject>("projects", cm => { cm.SetDiscriminator("lexicon"); }, true); return(services); }
/*******************************************/ private static void RegisterSerializers() { try { BsonSerializer.RegisterSerializer(typeof(object), new BH_ObjectSerializer()); BsonSerializer.RegisterSerializer(typeof(System.Drawing.Color), new ColourSerializer()); BsonSerializer.RegisterSerializer(typeof(MethodBase), new MethodBaseSerializer()); BsonSerializer.RegisterSerializer(typeof(Guid), new GuidSerializer(BsonType.String)); BsonSerializer.RegisterSerializer(typeof(CustomObject), new CustomObjectSerializer()); BsonSerializer.RegisterSerializer(typeof(Enum), new EnumSerializer()); BsonSerializer.RegisterSerializer(typeof(IDeprecated), new DeprecatedSerializer()); BsonSerializer.RegisterSerializer(typeof(DataTable), new DataTableSerialiser()); BsonSerializer.RegisterSerializer(typeof(Bitmap), new BitmapSerializer()); BsonSerializer.RegisterSerializer(typeof(IntPtr), new IntPtrSerializer()); BsonSerializer.RegisterSerializer(typeof(Regex), new RegexSerializer()); var typeSerializer = new TypeSerializer(); BsonSerializer.RegisterSerializer(typeof(Type), typeSerializer); BsonSerializer.RegisterSerializer(Type.GetType("System.RuntimeType"), typeSerializer); BsonDefaults.DynamicDocumentSerializer = new CustomObjectSerializer(); BsonSerializer.RegisterDiscriminatorConvention(typeof(IBHoMObject), new BHoMObjectDiscriminatorConvention()); BsonSerializer.RegisterDiscriminatorConvention(typeof(IObject), new BHoMObjectDiscriminatorConvention()); } catch (Exception) { Debug.WriteLine("Problem with initialisation of the Bson Serializer"); } }
protected void SetUp() { var f = new FileStream("config.json", FileMode.Open); var sr = new StreamReader(f); try { var settings = JsonConvert .DeserializeObject <MongoSettings>(sr.ReadToEnd()); var client = new MongoClient(new MongoUrl(settings.Url)); _database = client.GetDatabase(settings.DatabaseName); } catch (FileNotFoundException) { throw new Exception("Talk to John about why this one fails"); } finally { f.Dispose(); sr.Dispose(); } _collectionName = Guid.NewGuid().ToString(); _collection = _database.GetCollection <Container>(_collectionName); var mapper = new StringMapper <BasePaymentModel>(x => x.PaymentType) .Register <AchInputModel>("ach") .Register <CreditCardInputModel>("cc") .Register <PayPalInputModel>("paypal"); BsonSerializer.RegisterDiscriminatorConvention( typeof(BasePaymentModel), new DiscriminatorConvention <string, BasePaymentModel>(mapper)); }
/*******************************************/ /**** Public Methods ****/ /*******************************************/ public static void RegisterClassMap(Type type) { if (!BsonClassMap.IsClassMapRegistered(type)) { try { if (type.IsEnum) { MethodInfo generic = m_CreateEnumSerializer.MakeGenericMethod(type); generic.Invoke(null, null); } else if (!type.IsGenericTypeDefinition) { BsonClassMap cm = new BsonClassMap(type); cm.AutoMap(); cm.SetDiscriminator(type.FullName); cm.SetDiscriminatorIsRequired(true); cm.SetIgnoreExtraElements(true); // It would have been nice to use cm.MapExtraElementsProperty("CustomData") but it doesn't work for inherited properties cm.SetIdMember(null); BsonClassMap.RegisterClassMap(cm); BsonSerializer.RegisterDiscriminatorConvention(type, new GenericDiscriminatorConvention()); } else { BsonSerializer.RegisterDiscriminatorConvention(type, new GenericDiscriminatorConvention()); } } catch (Exception e) { Debug.WriteLine(e.ToString()); } } }
private void RegisterConventions() { var pack = new ConventionPack { new IgnoreIfNullConvention(true), /*new MongoRefConvention(),*/ new IgnoreExtraElementsConvention(true) }; ConventionRegistry.Register("Custom Conventions", pack, t => true); try { BsonSerializer.RegisterGenericSerializerDefinition(typeof(MongoRef <>), typeof(MongoRefSerializer <>)); } catch (BsonSerializationException bsex) when(bsex.Message == "There is already a serializer mapping registered for type MongoRef<T>.") { } try { BsonSerializer.RegisterDiscriminatorConvention(typeof(FileAction), new ContentTypeDiscriminatorConvention()); } catch (Exception e) { } if (!BsonClassMap.IsClassMapRegistered(typeof(MongoEntity))) { BsonClassMap.RegisterClassMap <MongoEntity>(delegate(BsonClassMap <MongoEntity> map) { map.AutoMap(); //map.MapProperty(f => f.ParentId).SetSerializer(new StringSerializer().WithRepresentation(BsonType.ObjectId)); map.IdMemberMap.SetSerializer(new StringSerializer().WithRepresentation(BsonType.ObjectId)).SetIdGenerator(StringObjectIdGenerator.Instance);; }); } }
/*******************************************/ private static void RegisterClassMaps() { MethodInfo method = typeof(BH.Engine.Serialiser.Convert).GetMethod("CreateEnumSerializer", BindingFlags.NonPublic | BindingFlags.Static); foreach (Type type in BH.Engine.Reflection.Query.BHoMTypeList()) { if (!BsonClassMap.IsClassMapRegistered(type)) { if (type.IsEnum) { MethodInfo generic = method.MakeGenericMethod(type); generic.Invoke(null, null); } else if (!type.IsGenericType) { Compute.RegisterClassMap(type); } else { BsonSerializer.RegisterDiscriminatorConvention(type, new GenericDiscriminatorConvention()); } } } Compute.RegisterClassMap(typeof(System.Drawing.Color)); Compute.RegisterClassMap(typeof(MethodInfo)); Compute.RegisterClassMap(typeof(ConstructorInfo)); Compute.RegisterClassMap(typeof(Bitmap)); Compute.RegisterClassMap(typeof(IntPtr)); Compute.RegisterClassMap(typeof(Regex)); }
//--- CONSTRUCTORS /// <summary> /// Use static constructor to set discriminator convention. /// /// This call is in static constructor because MongoDB driver /// complains if it is called more than once. /// </summary> static MongoDataSource() { // Set discriminator convention to hierarchical. For this convention, // BSON element _t is either an array of GetType().Name values for ell // types in the inheritance chain, or a single string value for a chain // of length 1. // // Choosing root type to be Record ensures that _t is always an array. BsonSerializer.RegisterDiscriminatorConvention(typeof(Data), new HierarchicalDiscriminatorConvention("_t")); }
private void ProcessTypeToRegisterForBson( TypeToRegisterForBson typeToRegisterForBson, SerializationConfigurationType registeringSerializationConfigurationType) { var type = typeToRegisterForBson.Type; var bsonSerializerBuilder = typeToRegisterForBson.BsonSerializerBuilder; var propertyNameWhitelist = typeToRegisterForBson.PropertyNameWhitelist; if (registeringSerializationConfigurationType == this.SerializationConfigurationType) { if (bsonSerializerBuilder == null) { try { if (type.IsClass) { var bsonClassMap = AutomaticallyBuildBsonClassMap(type, propertyNameWhitelist); BsonClassMap.RegisterClassMap(bsonClassMap); } // we are not 100% sure whether interface types or abstract types need to be registered // but there doesn't seem to be any harm in doing so. BsonSerializer.RegisterDiscriminatorConvention(type, ObcBsonDiscriminatorConvention.Instance); } catch (Exception ex) { throw new BsonSerializationConfigurationException(Invariant($"Failed to run {nameof(BsonClassMap.RegisterClassMap)} on {type.FullName}"), ex); } } else { // see comments in RegisteredTypeBsonSerializer<T> for why we are wrapping the serializer var registeredTypeBsonSerializer = RegisteredTypeBsonSerializer.Build(type, bsonSerializerBuilder.BsonSerializerBuilderFunc()); BsonSerializer.RegisterSerializer(type, registeredTypeBsonSerializer); } } if (bsonSerializerBuilder != null) { this.typesWithCustomSerializerOrPropertyNamesWhitelist.Add(type, null); if (bsonSerializerBuilder.OutputKind == BsonSerializerOutputKind.String) { this.typesWithCustomStringSerializers.Add(type, null); } } if (propertyNameWhitelist != null) { this.typesWithCustomSerializerOrPropertyNamesWhitelist.Add(type, null); } }
public static void Init() { var dis = new TypeDiscriminator(typeof(AbstractDownloadState), AbstractDownloadState.NameToType, AbstractDownloadState.TypeToName); BsonSerializer.RegisterDiscriminatorConvention(typeof(AbstractDownloadState), dis); BsonClassMap.RegisterClassMap <AbstractDownloadState>(cm => cm.SetIsRootClass(true)); dis = new TypeDiscriminator(typeof(AJobPayload), AJobPayload.NameToType, AJobPayload.TypeToName); BsonSerializer.RegisterDiscriminatorConvention(typeof(AJobPayload), dis); BsonClassMap.RegisterClassMap <AJobPayload>(cm => cm.SetIsRootClass(true)); }
private IMongoDatabase InitializeDatabase() { BsonSerializer.RegisterDiscriminatorConvention(typeof(BaseProperty), new BasePropertyDiscriminator()); BsonSerializer.RegisterDiscriminatorConvention(typeof(Entity), new EntityDiscriminator()); MapEntities(); // Mongo client var client = new MongoClient("mongodb+srv://m001-student:m001-mongodb-basics@" + "sandbox.aidnp.mongodb.net/temp?retryWrites=true&w=majority"); return(client.GetDatabase("Live2K")); }
public void RegisterClassMapsForDerivedClassesOf(Type baseClass) { // TODO: If derived types need extra registration steps, figure out how to discover that here. // Current idea is to have an ExtraRegistrationSteps function that does extra steps based on // what the type is, and derived classes like MongoRegistrarForLfConfig can override that function. BsonSerializer.RegisterDiscriminatorConvention(baseClass, new ScalarDiscriminatorConvention("type")); foreach (Type type in Assembly.GetAssembly(baseClass).GetTypes() .Where(thisType => thisType.IsClass && !thisType.IsAbstract && thisType.IsSubclassOf(baseClass))) { RegisterClassWithDiscriminator(type); } }
protected BsonClassMap Create <T>(Definitions.ItemDefinition definition, IEnumerable <Definitions.ItemDefinition> allDefinitions) where T : ContentItem { return(new BsonClassMap <T>(cm => { cm.SetDiscriminator(definition.Discriminator); BsonSerializer.RegisterDiscriminatorConvention(definition.ItemType, new IgnoreProxyTypeDiscriminatorConvention()); foreach (var type in allDefinitions.Select(d => d.ItemType).Where(t => definition.ItemType.IsAssignableFrom(t))) { cm.AddKnownType(type); } cm.AutoMap(); cm.SetCreator(() => { try { return database.IdentityMap.Current ?? CreateItem <T>(definition, proxies, database); } finally { database.IdentityMap.Current = null; } }); foreach (var p in definition.Properties.Values .Where(p => p.Info != null) .Where(p => typeof(ContentItem).IsAssignableFrom(p.Info.PropertyType)) .Where(p => p.Info.DeclaringType == definition.ItemType)) { if (p.Info.CanRead && p.Info.CanWrite) { cm.GetMemberMap(p.Name).SetSerializer(new ContentItemReferenceSerializer(database)); } else { cm.UnmapProperty(p.Name); } } cm.SetIgnoreExtraElements(true); })); }
/*******************************************/ private static void RegisterClassMap(Type type) { try { BsonClassMap cm = new BsonClassMap(type); cm.AutoMap(); cm.SetDiscriminator(type.FullName); cm.SetDiscriminatorIsRequired(true); cm.SetIgnoreExtraElements(false); // It would have been nice to use cm.MapExtraElementsProperty("CustomData") but it doesn't work for inherited properties BsonClassMap.RegisterClassMap(cm); BsonSerializer.RegisterDiscriminatorConvention(type, new GenericDiscriminatorConvention()); } catch (Exception e) { Debug.WriteLine(e.ToString()); } }
/// <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. } } }
public MongoResponseCache(string connectionString) { BsonSerializer.RegisterDiscriminatorConvention(typeof(Response), new TypeDiscriminatorConvention()); BsonClassMap.RegisterClassMap <Response>(cm => { cm.AutoMap(); cm.MapProperty(x => x.Type).SetRepresentation(BsonType.String); }); BsonClassMap.RegisterClassMap <Error>(); BsonClassMap.RegisterClassMap <Link>(); BsonClassMap.RegisterClassMap <Photo>(); BsonClassMap.RegisterClassMap <Rich>(); BsonClassMap.RegisterClassMap <Video>(); var url = MongoUrl.Create(connectionString); var client = new MongoClient(url); var server = client.GetServer(); var database = server.GetDatabase(url.DatabaseName); _collection = database.GetCollection <MongoCacheItem>("embedly"); }
public void Register(TinyIoCContainer container) { container.Register <ISettingService, SettingService>(); container.Register(typeof(IConfigurationProvider <>), typeof(ConfigurationProvider <>)); container.Register((context, p) => GetSettingsDatabase(context)); container.Register((context, p) => GetSettingsDatabase(context).GetCollection <Setting>("Settings")); container.ResolveUnregisteredType += (sender, e) => { if (typeof(ISettings).IsAssignableFrom(e.Request.Type)) { var buildMethod = BuildSettingsMethod.MakeGenericMethod(e.Request.Type); e.Result = buildMethod.Invoke(null, new object[] { container }); } }; try { BsonSerializer.RegisterDiscriminatorConvention(typeof(Setting), new SettingsDiscriminatorConvention()); }catch (BsonSerializationException ex) { // ensure that we can call this multiple times in same app domain for unit tests } }
/*******************************************/ private static void RegisterTypes() { // Define the conventions var pack = new ConventionPack(); pack.Add(new ImmutableBHoMClassMapConvention()); pack.Add(new ImmutableBHoMCreatorMapConvention()); pack.Add(new BHoMDictionaryConvention()); ConventionRegistry.Register("BHoM Conventions", pack, x => x is object); var pack2 = new ConventionPack(); pack2.Add(new BHoMEnumConvention()); ConventionRegistry.Register("Enum Conventions", pack2, x => x.GetType().IsEnum); // Register additional serialisers try { BsonSerializer.RegisterSerializer(typeof(object), new BH_ObjectSerializer()); BsonSerializer.RegisterSerializer(typeof(System.Drawing.Color), new ColourSerializer()); BsonSerializer.RegisterSerializer(typeof(MethodBase), new MethodBaseSerializer()); BsonSerializer.RegisterSerializer(typeof(Guid), new GuidSerializer(BsonType.String)); BsonSerializer.RegisterSerializer(typeof(CustomObject), new CustomObjectSerializer()); BsonSerializer.RegisterSerializer(typeof(Enum), new EnumSerializer()); BsonSerializer.RegisterSerializer(typeof(IDeprecated), new DeprecatedSerializer()); BsonSerializer.RegisterSerializer(typeof(DataTable), new DataTableSerialiser()); var typeSerializer = new TypeSerializer(); BsonSerializer.RegisterSerializer(typeof(Type), typeSerializer); BsonSerializer.RegisterSerializer(Type.GetType("System.RuntimeType"), typeSerializer); BsonDefaults.DynamicDocumentSerializer = new CustomObjectSerializer(); BsonSerializer.RegisterDiscriminatorConvention(typeof(object), new GenericDiscriminatorConvention()); } catch (Exception) { Debug.WriteLine("Problem with initialisation of the Bson Serializer"); } // Register class maps MethodInfo method = typeof(BH.Engine.Serialiser.Convert).GetMethod("CreateEnumSerializer", BindingFlags.NonPublic | BindingFlags.Static); foreach (Type type in BH.Engine.Reflection.Query.BHoMTypeList()) { if (!BsonClassMap.IsClassMapRegistered(type)) { if (type.IsEnum) { MethodInfo generic = method.MakeGenericMethod(type); generic.Invoke(null, null); } else if (!type.IsGenericType) { RegisterClassMap(type); } } } RegisterClassMap(typeof(System.Drawing.Color)); RegisterClassMap(typeof(MethodInfo)); RegisterClassMap(typeof(ConstructorInfo)); m_TypesRegistered = true; }
public MongoDatabaseService(MongoDBSettings mongoDBSettings) { Database = new MongoClient(mongoDBSettings.ConnectionString).GetDatabase(mongoDBSettings.DatabaseName); BsonSerializer.RegisterDiscriminatorConvention(typeof(Item), new DiscriminatorConvention()); }
static A() { BsonSerializer.RegisterDiscriminatorConvention(typeof(A), new MagicDiscriminatorConvention()); }
private void RegisterDiscriminators() { BsonSerializer.RegisterDiscriminatorConvention(typeof(OrderModel), new OrderModelDiscriminator()); BsonSerializer.RegisterDiscriminatorConvention(typeof(JobTask), new JobTaskDiscriminator()); }
public static void RegisterDiscriminatorConvention(Type type) { BsonSerializer.RegisterDiscriminatorConvention(type, NoDiscriminatorConventionInstance); }
public static IEventSourcingBuilder AddMongo(this IServiceCollection services) { services.AddSingleton <IConfigureOptions <MongoOptions> >(s => new MongoOptionsConfigure( s.GetRequiredService <IConfiguration>() )); services.AddSingleton <IMongoClient>(s => { var options = s.GetRequiredService <IOptions <MongoOptions> >().Value; var mappers = s.GetServices <Action <IMapState> >().ToList(); foreach (var mapper in mappers) { mapper(new MongoStateMapper(s)); } if (!Initialized) { Initialized = true; BsonSerializer.RegisterDiscriminatorConvention( typeof(object), new ScalarDiscriminatorConvention("_t") ); BsonClassMap.RegisterClassMap <Envelope>(map => { map.AutoMap(); map.MapIdProperty(x => x.MessageId) .SetIdGenerator(StringObjectIdGenerator.Instance) .SetSerializer(new StringSerializer(BsonType.String)); }); BsonClassMap.RegisterClassMap <Snapshot>(map => { map.AutoMap(); map.MapIdProperty(p => p.SnapshotId); }); } return(new MongoClient(options.ConnectionString)); }); services.AddSingleton <IMongoDatabase>(s => s .GetRequiredService <IMongoClient>() .GetDatabase( s.GetRequiredService <IOptions <MongoOptions> >().Value.Database )); services.AddSingleton(s => new List <IMapState>()); services.AddSingleton(s => new MongoStore( s.GetRequiredService <ILoggerFactory>().CreateLogger <MongoStore>(), s.GetRequiredService <IClientSessionHandle>(), s.GetRequiredService <IMongoCollection <Envelope> >(), s.GetRequiredService <IMongoCollection <Snapshot> >() )); services.AddSingleton(s => s .GetRequiredService <IMongoDatabase>() .GetCollection <Envelope>( s.GetService <IOptions <MongoOptions> >().Value.EventCollection )); services.AddSingleton(s => s .GetRequiredService <IMongoDatabase>() .GetCollection <Snapshot>( s.GetService <IOptions <MongoOptions> >().Value.SnapshotCollection ) ); services.AddSingleton <IStoreEvents>(s => s.GetRequiredService <MongoStore>()); services.AddSingleton <IStoreSnapshots>(s => s.GetRequiredService <MongoStore>()); services.AddTransient <IClientSessionHandle>(s => s.GetService <IMongoClient>().StartSession()); services.AddTransient <IHostedService>(s => new MongoInitializationService( s.GetRequiredService <IMongoCollection <Envelope> >(), s.GetRequiredService <IMongoCollection <Snapshot> >() )); return(new MongoServiceBuilder(services)); }
public static IServiceCollection AddMongoDataAccess(this IServiceCollection services, IConfiguration configuration) { IConfigurationSection dataAccessConfig = configuration.GetSection("DataAccess"); string connectionString = dataAccessConfig.GetValue <string>("ConnectionString", "mongodb://localhost:27017"); string jobDatabase = dataAccessConfig.GetValue <string>("JobDatabase", "jobs"); services.AddHangfire(x => x.UseMongoStorage(connectionString, jobDatabase, new MongoStorageOptions { MigrationOptions = new MongoMigrationOptions { Strategy = MongoMigrationStrategy.Migrate } })); BsonSerializer.RegisterDiscriminatorConvention(typeof(Project), new HierarchicalDiscriminatorConvention("appName")); BsonSerializer.RegisterDiscriminatorConvention(typeof(LexConfig), new HierarchicalDiscriminatorConvention("type")); BsonSerializer.RegisterDiscriminatorConvention(typeof(LexViewFieldConfig), new HierarchicalDiscriminatorConvention("type")); BsonSerializer.RegisterDiscriminatorConvention(typeof(LexTask), new HierarchicalDiscriminatorConvention("type")); var globalPack = new ConventionPack { new CamelCaseElementNameConvention(), new ObjectRefConvention() }; ConventionRegistry.Register("Global", globalPack, t => true); var paratextProjectPack = new ConventionPack { new NoIdMemberConvention() }; ConventionRegistry.Register("ParatextProject", paratextProjectPack, t => t == typeof(ParatextProject)); RegisterClass <EntityBase>(cm => { cm.MapIdProperty(e => e.Id) .SetIdGenerator(StringObjectIdGenerator.Instance) .SetSerializer(new StringSerializer(BsonType.ObjectId)); }); RegisterClass <LexConfig>(cm => { cm.MapMember(lc => lc.HideIfEmpty).SetSerializer(new EmptyStringBooleanSerializer()); }); RegisterClass <LexConfigFieldList>(cm => cm.SetDiscriminator(LexConfig.FieldList)); RegisterClass <LexConfigOptionList>(cm => cm.SetDiscriminator(LexConfig.OptionList)); RegisterClass <LexConfigMultiOptionList>(cm => cm.SetDiscriminator(LexConfig.MultiOptionList)); RegisterClass <LexConfigMultiText>(cm => cm.SetDiscriminator(LexConfig.MultiText)); RegisterClass <LexConfigPictures>(cm => cm.SetDiscriminator(LexConfig.Pictures)); RegisterClass <LexConfigMultiParagraph>(cm => cm.SetDiscriminator(LexConfig.MultiParagraph)); RegisterClass <LexViewFieldConfig>(cm => cm.SetDiscriminator("basic")); RegisterClass <LexViewMultiTextFieldConfig>(cm => cm.SetDiscriminator("multitext")); RegisterClass <LexTask>(cm => cm.SetDiscriminator("")); RegisterClass <LexTaskDashboard>(cm => cm.SetDiscriminator(LexTask.Dashboard)); RegisterClass <LexTaskSemdom>(cm => cm.SetDiscriminator(LexTask.Semdom)); RegisterClass <LexAuthorInfo>(cm => { cm.MapMember(a => a.ModifiedByUserRef) .SetSerializer(new StringSerializer(BsonType.ObjectId)); cm.MapMember(a => a.CreatedByUserRef) .SetSerializer(new StringSerializer(BsonType.ObjectId)); }); RegisterClass <LexSense>(cm => { cm.UnmapMember(s => s.CustomFields); cm.UnmapMember(s => s.AuthorInfo); cm.UnmapMember(s => s.ReversalEntries); }); services.AddSingleton <IMongoClient>(sp => new MongoClient(connectionString)); services.AddMongoRepository <SendReceiveJob>("send_receive"); services.AddMongoRepository <User>("users", cm => { cm.MapMember(u => u.SiteRole).SetSerializer( new DictionaryInterfaceImplementerSerializer <Dictionary <string, string> >( DictionaryRepresentation.Document, new SiteDomainSerializer(), new StringSerializer())); cm.MapMember(u => u.Projects) .SetSerializer(new EnumerableInterfaceImplementerSerializer <List <string>, string>( new StringSerializer(BsonType.ObjectId))); }); services.AddMongoRepository <Project>("projects"); services.AddMongoRepository <LexProject>("projects", cm => cm.SetDiscriminator("lexicon")); services.AddMongoRepository <TranslateProject>("projects", cm => cm.SetDiscriminator("translate")); services.AddMongoProjectRepositoryFactory <TranslateDocumentSet>("translate"); services.AddMongoProjectRepositoryFactory <LexEntry>("lexicon", cm => { cm.UnmapMember(e => e.Environments); cm.UnmapMember(e => e.MorphologyType); }); return(services); }
/// <summary> /// Sets our custom <see cref="IDiscriminatorConvention"/>'s. /// </summary> /// <remarks> /// DiscriminatorConvetions need to be registered before everything else is done with MongoDB, otherwise the classes /// will get assiged a BsonClassMapSerializer implicitly. We can also only register them once, multiple registrations /// result in errors. /// https://stackoverflow.com/a/30292486/5806412 . /// </remarks> static void RegisterCustomDiscriminators() { BsonSerializer.RegisterDiscriminatorConvention(typeof(AbstractStreamProcessorState), new StreamProcessorStateDiscriminatorConvention()); BsonSerializer.RegisterDiscriminatorConvention(typeof(AbstractFilterDefinition), new FilterDefinitionDiscriminatorConvention()); }
public static void RegisterConcreteClass <TBase, TConcrete>() { BsonSerializer.RegisterDiscriminatorConvention(typeof(TBase), new SingleDiscriminatorConvention(typeof(TConcrete))); BsonClassMap.RegisterClassMap <TConcrete>(); }
public static void Configure() { BsonSerializer.RegisterDiscriminatorConvention(typeof(OrderModel), new OrderModelDiscriminator()); BsonSerializer.RegisterDiscriminatorConvention(typeof(JobTask), new JobTaskDiscriminator()); }