private static void SetupSerialisationAndMapping() { if (BsonClassMap.GetRegisteredClassMaps().FirstOrDefault(p => p.ClassType == typeof(T)) == null) { BsonClassMap.RegisterClassMap <T>(cm => { cm.AutoMap(); cm.SetIgnoreExtraElements(true); cm.SetIdMember(cm.GetMemberMap(c => c._recordId)); }); } var usedTypes = GetContainingTypes(typeof(T)); foreach (var type in usedTypes) { var existing = BsonClassMap.GetRegisteredClassMaps().FirstOrDefault(p => p.ClassType == type); if (existing == null) { var bsonMap = new BsonClassMap(type); bsonMap.AutoMap(); bsonMap.SetIgnoreExtraElements(true); BsonClassMap.RegisterClassMap(bsonMap); } } try { BsonSerializer.RegisterSerializer(typeof(UInt64), new UInt64Serializer(BsonType.Int64, new RepresentationConverter(true, false))); BsonSerializer.RegisterSerializer(typeof(UInt32), new UInt32Serializer(BsonType.Int64, new RepresentationConverter(true, false))); BsonSerializer.RegisterSerializer(DateTimeSerializer.LocalInstance); BsonSerializer.RegisterSerializer(typeof(float), new FloatTruncationSerializer()); } catch (BsonSerializationException) { // swallow; } }
public InventoryManager() { _activeInvsBeingManaged = new Dictionary <Client, KeyValuePair <IStorage, IStorage> >(); #region Inventory Items BsonClassMap.RegisterClassMap <BagItem>(); BsonClassMap.RegisterClassMap <Phone>(); BsonClassMap.RegisterClassMap <Money>(); BsonClassMap.RegisterClassMap <EngineParts>(); BsonClassMap.RegisterClassMap <SprayPaint>(); BsonClassMap.RegisterClassMap <Fish>(); BsonClassMap.RegisterClassMap <RopeItem>(); BsonClassMap.RegisterClassMap <RagsItem>(); BsonClassMap.RegisterClassMap <SprunkItem>(); BsonClassMap.RegisterClassMap <CheckItem>(); BsonClassMap.RegisterClassMap <HuntingTag>(); BsonClassMap.RegisterClassMap <AnimalItem>(); BsonClassMap.RegisterClassMap <AmmoItem>(); BsonClassMap.RegisterClassMap <ScubaItem>(); BsonClassMap.RegisterClassMap <SupplyItem>(); BsonClassMap.RegisterClassMap <IdentificationItem>(); BsonClassMap.RegisterClassMap <DrivingLicenseItem>(); BsonClassMap.RegisterClassMap <FishingRod>(); BsonClassMap.RegisterClassMap <Cocaine>(); BsonClassMap.RegisterClassMap <Heroin>(); BsonClassMap.RegisterClassMap <Speed>(); BsonClassMap.RegisterClassMap <Weed>(); BsonClassMap.RegisterClassMap <Meth>(); BsonClassMap.RegisterClassMap <Crowbar>(); BsonClassMap.RegisterClassMap <WeaponCase>(); BsonClassMap.RegisterClassMap <Weapon>(); #endregion Event.OnClientEventTrigger += API_onClientEventTrigger; CharacterMenu.OnCharacterLogin += CharacterMenu_OnCharacterLogin; }
public DataContext(AppSettings settings) { var client = new MongoClient(settings.Db.ConnectionString); BsonClassMap.RegisterClassMap <User>(cm => { cm.AutoMap(); cm.MapIdMember(c => c.Id) .SetIdGenerator(StringObjectIdGenerator.Instance) .SetSerializer(new StringSerializer(BsonType.ObjectId)); }); BsonClassMap.RegisterClassMap <Alert>(cm => { cm.AutoMap(); cm.MapIdMember(c => c.Id) .SetIdGenerator(StringObjectIdGenerator.Instance) .SetSerializer(new StringSerializer(BsonType.ObjectId)); }); BsonClassMap.RegisterClassMap <Asic>(cm => { cm.AutoMap(); cm.MapIdMember(c => c.Id) .SetIdGenerator(StringObjectIdGenerator.Instance) .SetSerializer(new StringSerializer(BsonType.ObjectId)); }); BsonClassMap.RegisterClassMap <HardwareCost>(cm => { cm.AutoMap(); cm.MapIdMember(c => c.Id) .SetIdGenerator(StringObjectIdGenerator.Instance) .SetSerializer(new StringSerializer(BsonType.ObjectId)); }); _database = client.GetDatabase(settings.Db.DatabaseName); }
public static void RegisterClassMaps() { BsonClassMap.RegisterClassMap <WorkflowMetadata>(cm => WorkflowsClassMap.Register(cm)); BsonClassMap.RegisterClassMap <Workflow>(seq => WorkflowsClassMap.Register(seq)); BsonClassMap.RegisterClassMap <WorkflowTemplate>(seq => WorkflowTemplatesClassMap.Register(seq)); BsonClassMap.RegisterClassMap <StepTemplate>(cm => StepTemplatesClassMap.Register(cm)); BsonClassMap.RegisterClassMap <Journal>(je => JournalsClassMap.Register(je)); BsonClassMap.RegisterClassMap <Step>(cm => StepsClassMap.Register(cm)); BsonClassMap.RegisterClassMap <StepLog>(cm => StepLogsClassMap.Register(cm)); BsonClassMap.RegisterClassMap <User>(u => UsersClassMap.Register(u)); BsonClassMap.RegisterClassMap <GlobalValue>(gv => GlobalValuesClassMap.Register(gv)); BsonClassMap.RegisterClassMap <TrackedEntity>(gv => TrackedEntitiesClassMap.Register(gv)); BsonClassMap.RegisterClassMap <Condition>(gv => ConditionsClassMap.Register(gv)); BsonClassMap.RegisterClassMap <LogEntry>(); BsonClassMap.RegisterClassMap <NodeInformation>(); BsonClassMap.RegisterClassMap <Index>(); BsonClassMap.RegisterClassMap <BaseTask>(); BsonClassMap.RegisterClassMap <Lock>(); BsonClassMap.RegisterClassMap <LogicBlockLock>(); BsonClassMap.RegisterClassMap <BaseCommand>(gv => BaseCommandsClassMap.Register(gv)); BsonClassMap.RegisterClassMap <NodeStorage <CindiClusterState> >(gv => NodeStorageClassMap.Register(gv)); BsonClassMap.RegisterClassMap <Update>(gv => UpdateClassMap.Register(gv)); BsonClassMap.RegisterClassMap <ShardMetadata>(lsm => LocalShardMetaDataClassMap.Register(lsm)); BsonClassMap.RegisterClassMap <CindiClusterState>(cs => CindiClusterStateClassMap.Register(cs)); BsonClassMap.RegisterClassMap <ShardWriteOperation>(cs => ShardOperationClassMap.Register(cs)); BsonClassMap.RegisterClassMap <BaseState>(cs => BaseStateClassMap.Register(cs)); BsonClassMap.RegisterClassMap <JournalEntry>(cs => JournalEntriesClassMap.Register(cs)); BsonClassMap.RegisterClassMap <Domain.Entities.Metrics.Metric>(cs => MetricsClassMap.Register(cs)); BsonClassMap.RegisterClassMap <MetricTick>(cs => MetricTickClassMap.Register(cs)); BsonClassMap.RegisterClassMap <BotKey>(cs => BotKeyClassMap.Register(cs)); BsonClassMap.RegisterClassMap <ExecutionTemplate>(cs => ExecutionTemplateClassMap.Register(cs)); BsonClassMap.RegisterClassMap <ExecutionSchedule>(cs => ExecutionScheduleClassMap.Register(cs)); //BsonSerializer.RegisterSerializer(typeof(Update), new UpdateSerializer()); /*BsonSerializer.RegisterSerializer(typeof(BaseCommand), new BaseCommandSerializer()); * BsonSerializer.RegisterSerializer(typeof(NodeStorage), new NodeStorageSerializer()); * BsonSerializer.RegisterSerializer(typeof(Update), new UpdateSerializer());*/ }
public void ApplyReplaceArray(string path, object value, bool isArray) { var converter = Helper.GetConverter(); var doc = new JsonPatchDocument <UserEntity>(); BsonClassMap.RegisterClassMap <UserEntity>(); doc.Operations.Add(new Operation <UserEntity> { from = string.Empty, op = "replace", path = path, value = isArray ? JArray.Parse((string)value) : value }); var result = converter.Convert <UserEntity, UserEntity>(doc); using (var coll = Helper.GetCollection <UserEntity>()) { var filtered = Builders <UserEntity> .Filter.And(result.Filters); var updates = Builders <UserEntity> .Update.Combine(result.Updates); coll.Collection.InsertOne(new UserEntity { Id = Guid.NewGuid(), Dogs = new [] { new Dog { Name = "Don" } } }); var updateResult = coll.Collection.UpdateOne(filtered, updates); Assert.True(updateResult.ModifiedCount > 0); var entities = coll.Collection.Find("{}").ToList(); Assert.True(entities.Any()); Assert.NotNull(entities[0].Dogs); Assert.True(entities[0].Dogs.Any()); Assert.True(entities[0].Dogs[0].Name != "Don"); } }
private void LoadDataFromDB() { // Create server settings to pass connection string, timeout, etc. MongoServerSettings settings = new MongoServerSettings(); settings.Server = new MongoServerAddress("localhost", 27017); //// Create server object to communicate with our server MongoServer server = new MongoServer(settings); if (!BsonClassMap.IsClassMapRegistered(typeof(IPerson))) { BsonClassMap.RegisterClassMap <IPerson>(cm => { cm.AutoMap(); cm.SetIdMember(cm.GetMemberMap(c => c.registrationNumber)); } ); // Console.WriteLine("Registering Class"); } if (!BsonClassMap.IsClassMapRegistered(typeof(SourceAFIS.Simple.Fingerprint))) { BsonClassMap.RegisterClassMap <SourceAFIS.Simple.Fingerprint>(cm => { cm.MapProperty <byte[, ]>(c => c.Image); cm.MapProperty <byte[]>(c => c.Template); cm.UnmapField(c => c.AsBitmap); cm.MapProperty <byte[]>(c => c.AsImageData); cm.MapProperty <byte[]>(c => c.AsIsoTemplate); cm.UnmapField(c => c.AsXmlTemplate); } ); } var database = server.GetDatabase("AfisDB"); dbrecords = database.GetCollection <IPerson>("IPerson"); }
private static bool Map() { if (BsonClassMap.IsClassMapRegistered(typeof(Entity))) { return(false); } try { BsonClassMap.RegisterClassMap <Entity>(cm => { cm.SetIsRootClass(true); cm.MapIdProperty(x => x.Id); }); BsonClassMap.RegisterClassMap <WorkflowDefinition>(cm => { cm.MapProperty(p => p.Variables).SetSerializer(VariablesSerializer.Instance); cm.AutoMap(); }); BsonClassMap.RegisterClassMap <WorkflowInstance>(cm => { cm.MapProperty(p => p.Variables).SetSerializer(VariablesSerializer.Instance); cm.AutoMap(); }); BsonClassMap.RegisterClassMap <Bookmark>(cm => cm.AutoMap()); BsonClassMap.RegisterClassMap <WorkflowExecutionLogRecord>(cm => cm.AutoMap()); BsonClassMap.RegisterClassMap <WorkflowOutputReference>(cm => cm.AutoMap()); } catch (Exception) { return(false); } return(true); }
/// <summary> /// Register MongoDB mappings /// </summary> public static void RegisterMongoDBMappings() { //BsonSerializer.RegisterSerializer(new DecimalSerializer(BsonType.Decimal128)); //BsonSerializer.RegisterSerializer(typeof(double?), new NullableSerializer<double>(new DecimalSerializer(BsonType.Decimal128))); BsonSerializer.RegisterSerializer(typeof(DateTime), new BsonUtcDateTimeSerializer()); BsonSerializer.RegisterSerializer(typeof(Dictionary <int, int>), new DictionaryInterfaceImplementerSerializer <Dictionary <int, int> >(DictionaryRepresentation.ArrayOfArrays)); //global set an equivalent of [BsonIgnoreExtraElements] for every Domain Model var cp = new ConventionPack { new IgnoreExtraElementsConvention(true) }; ConventionRegistry.Register("ApplicationConventions", cp, t => true); BsonClassMap.RegisterClassMap <Media.Download>(cm => { cm.AutoMap(); cm.UnmapMember(m => m.DownloadBinary); }); }
public static void Configure() { OneTimeRunner.Run(() => { BsonClassMap.RegisterClassMap <IdentityUser>(map => { map.AutoMap(); map.ConfigureExtraProperties(); }); BsonClassMap.RegisterClassMap <IdentityRole>(map => { map.AutoMap(); map.ConfigureExtraProperties(); }); BsonClassMap.RegisterClassMap <IdentityClaimType>(map => { map.AutoMap(); map.ConfigureExtraProperties(); }); }); }
private void MapClasses() { // Vamos criar uma convenção para que o mongo trabalhe com CamelCase var conventionPack = new ConventionPack { new CamelCaseElementNameConvention() }; ConventionRegistry.Register("camelCase", conventionPack, t => true); // E caso não tenhamos nada mapeado, if (!BsonClassMap.IsClassMapRegistered(typeof(Infectado))) { BsonClassMap.RegisterClassMap <Infectado>(i => { /* * Aqui, vamos mapear no banco, com o mesmo nome e tipo da classe que fizemos. */ i.AutoMap(); // Para caso você apartir de hoje tenha uma nova coluna no documento, e o banco não estranhe... i.SetIgnoreExtraElements(true); }); } }
/// <summary> /// Configure Classes to ignore Extra Elements (e.g. _Id) when deserializing /// As we are using "IdentityServer4.Models" we cannot add something like "[BsonIgnore]" /// </summary> private static void ConfigureMongoDriver2IgnoreExtraElements() { BsonClassMap.RegisterClassMap <Client>(cm => { cm.AutoMap(); cm.SetIgnoreExtraElements(true); }); BsonClassMap.RegisterClassMap <IdentityResource>(cm => { cm.AutoMap(); cm.SetIgnoreExtraElements(true); }); BsonClassMap.RegisterClassMap <ApiResource>(cm => { cm.AutoMap(); cm.SetIgnoreExtraElements(true); }); BsonClassMap.RegisterClassMap <PersistedGrant>(cm => { cm.AutoMap(); cm.SetIgnoreExtraElements(true); }); }
public void Map() { BsonClassMap.RegisterClassMap <Base>(map => { map.AutoMap(); map.GetMemberMap(x => x.CreatedOn).SetSerializer(new DateTimeSerializer(DateTimeKind.Utc)); map.IdMemberMap.SetIdGenerator(StringObjectIdGenerator.Instance).SetSerializer(new StringSerializer(BsonType.ObjectId)); map.MapExtraElementsMember(x => x.ExtraElement); }); BsonClassMap.RegisterClassMap <Application>(map => { map.AutoMap(); }); var pack = new ConventionPack(); pack.Add(new CamelCaseElementNameConvention()); ConventionRegistry.Register( "My Custom Conventions", pack, t => t.FullName.StartsWith("MyNamespace.")); }
public DbContext( string connectionString, string database, ILogger <DbContext> logger) { _logger = logger; _logger.LogInformation("Connection to {@mongoUrl} at {@database}", connectionString, database); var mongoUrl = new MongoUrl(connectionString); Client = new MongoClient(mongoUrl); Database = Client.GetDatabase(database); if (!BsonClassMap.IsClassMapRegistered(typeof(ShortUrl))) { BsonClassMap.RegisterClassMap <ShortUrl>(cm => { cm.MapIdProperty(c => c.Id); cm.MapProperty(c => c.FullUrl); }); } }
public static void Setup() { BsonClassMap.RegisterClassMap <ServiceType>(cm => { cm.AutoMap(); cm.SetIsRootClass(true); }); BsonClassMap.RegisterClassMap <ServiceType.DeliveryType>(); BsonClassMap.RegisterClassMap <ServiceType.InRestaurantType>(); BsonClassMap.RegisterClassMap <ServiceType.TakeOutType>(); BsonClassMap.RegisterClassMap <Pizza>(cm => { cm.AutoMap(); cm.GetMemberMap(c => c.Toppings).SetElementName("Topping"); }); BsonClassMap.RegisterClassMap <Order>(cm => { cm.AutoMap(); cm.SetIgnoreExtraElements(true); }); }
private static void DefineClassMaps() { if (!BsonClassMap.IsClassMapRegistered(typeof(Project))) { BsonClassMap.RegisterClassMap <Project>(p => { p.AutoMap(); // explict version p.MapProperty(c => c.Id) .SetIdGenerator(StringObjectIdGenerator.Instance) .SetSerializer(new StringSerializer(BsonType.ObjectId)); // short version //p.IdMemberMap.SetSerializer(new StringSerializer(BsonType.ObjectId)); p.GetMemberMap(c => c.StartDate).SetSerializer(new DateTimeSerializer(true)); p.GetMemberMap(c => c.EndDate).SetSerializer(new DateTimeSerializer(true)); p.UnmapMember(c => c.Fee); }); } }
public static IRepository BuildMongoDbRepository(string url, bool reload = true) { var mongoUrl = new MongoUrl(url); var db = new MongoClient(mongoUrl).GetServer(); if (reload) { if (db.DatabaseExists(mongoUrl.DatabaseName)) { db.DropDatabase(mongoUrl.DatabaseName); } } if (!BsonClassMap.IsClassMapRegistered(typeof(IncEntityBase))) { BsonClassMap.RegisterClassMap <IncEntityBase>(map => map.UnmapProperty(r => r.Id)); } var session = new MongoDatabaseDisposable(db.GetDatabase(mongoUrl.DatabaseName)); var buildMongoDbRepository = new MongoDbRepository(/*Pleasure.MockStrictAsObject<IMongoDbSessionFactory>(mock => mock.Setup(r => r.GetCurrent()).Returns(session))*/); buildMongoDbRepository.SetProvider(session); return(buildMongoDbRepository); }
public static void AddMongoDb(this IServiceCollection services, Action <MongoSettings> settingsAction) { services.AddScoped <IMongoClient, MongoClient>(); services.AddScoped <IMongoContext, MongoDbContext>(); services.AddScoped <IUnitOfWork, UnitOfWork>(); var mongoSettings = new MongoSettings(); settingsAction(mongoSettings); services.AddSingleton(mongoSettings); if (BsonClassMap.IsClassMapRegistered(typeof(DomainEntity))) { return; } BsonClassMap.RegisterClassMap <DomainEntity>(cm => { cm.AutoMap(); cm.SetIsRootClass(true); cm.UnmapMember(x => x.ValidationResult); }); }
public virtual void RegisterClass() { m_Wheels = new Wheel[1]; m_Wheels[0] = new Wheel(0); m_Wheels[0].RegisterClass(); m_PowerSource.RegisterClass(); m_OwnerDetailes = new VehicleOwner(); m_OwnerDetailes.RegisterClass(); if (!BsonClassMap.IsClassMapRegistered(typeof(Vehicle))) { BsonClassMap.RegisterClassMap <Vehicle>(cm => { cm.SetIdMember(cm.MapField(c => c.r_LicensePlateNumber).SetElementName("LicensePlateNumber")); cm.MapField(c => c.m_ModelName).SetElementName("ModelName"); cm.MapField(c => c.m_OwnerDetailes).SetElementName("OwnerDetailes"); cm.MapField(c => c.m_PercentageOfEnergy).SetElementName("PercentageOfEnergy"); cm.MapField(c => c.m_PowerSource).SetElementName("PowerSource"); cm.MapField(c => c.m_Status).SetElementName("Status").SetSerializer(new EnumSerializer <eRepairStatus>(BsonType.String)); cm.MapField(c => c.m_Wheels).SetElementName("Wheels"); cm.MapField(c => c.m_TimeOfEnteringToGarage).SetElementName("TimeOfEnteringToGarage"); }); } }
static MongoDBDataStorageProvider() { ConventionPack pack = new ConventionPack { new EnumRepresentationConvention(BsonType.String) }; ConventionRegistry.Register("EnumStringConvention", pack, t => true); pack = new ConventionPack { new IgnoreIfNullConvention(true) }; ConventionRegistry.Register("IgnoreNull", pack, t => true); BsonClassMap.RegisterClassMap <AuditEvent>(cm => { cm.AutoMap(); cm.MapExtraElementsField(c => c.CustomFields); }); BsonSerializer.RegisterSerializer(typeof(FieldValueChange), new FieldValueChangeSerializer()); }
public DocumentTypeBuilder <T> Map(Action <BsonClassMap <T> > bsonClassMapAction) { try { if (!BsonClassMap.IsClassMapRegistered(typeof(T))) { BsonClassMap.RegisterClassMap <T>(bsonClassMapAction); } return(this); } catch (ArgumentException ex) { if (ex.Message.Contains("An item with the same key has already been added")) { return(this); } throw; } catch (Exception) { throw; } }
static MongoStorage() { // We will register all our Dto classes with the default conventions. // By doing this, we can safely use strings for referencing class // property names with risking to have a mismatch with any convention // used by bson serializer. var conventionPack = new ConventionPack(); conventionPack.Append(DefaultConventionPack.Instance); conventionPack.Append(AttributeConventionPack.Instance); var conventionRunner = new ConventionRunner(conventionPack); var assembly = typeof(MongoStorage).GetTypeInfo().Assembly; var classMaps = assembly.DefinedTypes .Where(t => t.IsClass && !t.IsAbstract && !t.IsGenericType && t.Namespace == "Hangfire.Mongo.Dto") .Select(t => new BsonClassMap(t.AsType())); foreach (var classMap in classMaps) { conventionRunner.Apply(classMap); BsonClassMap.RegisterClassMap(classMap); } }
public static void ProductMap() { if (!BsonClassMap.IsClassMapRegistered(typeof(Product))) { BsonClassMap.RegisterClassMap <Product>(map => { map.MapIdProperty(x => x.ProductId) .SetIdGenerator(MongoDBInt32IdGenerator.Instance) .SetSerializer(new StringSerializer(BsonType.String)); map.MapProperty(x => x.ProductId); map.MapProperty(x => x.ProductName); map.MapProperty(x => x.SupplierId); map.MapProperty(x => x.CategoryId); map.MapProperty(x => x.QuantityPerUnit); map.MapProperty(x => x.UnitPrice); map.MapProperty(x => x.UnitsInStock); map.MapProperty(x => x.UnitsOnOrder); map.MapProperty(x => x.ReorderLevel); map.MapProperty(x => x.Discontinued); }); } }
private void InitMappings() { BsonClassMap.RegisterClassMap <WeatherReport>(cm => { cm.MapMember(c => c.DraughtDays); cm.MapMember(c => c.MaxIntensityDay); cm.MapMember(c => c.MaxRainIntensity); cm.MapMember(c => c.RainDays); cm.MapMember(c => c.OptimumDays); }); BsonClassMap.RegisterClassMap <Weather>(cm => { cm.MapMember(c => c.Type).SetSerializer(new EnumSerializer <Weather.WeatherType>(BsonType.String)); cm.MapMember(c => c.RainIntensity); }); BsonClassMap.RegisterClassMap <DayReport>(cm => { cm.MapMember(c => c.Day); cm.MapMember(c => c.Weather); }); }
public static IServiceCollection AddMongoDB(this IServiceCollection services, string connectionString) { services.AddSingleton <IMongoDatabase>(x => { BsonDefaults.GuidRepresentation = GuidRepresentation.Standard; BsonClassMap.RegisterClassMap <Enumeration>(cm => { cm.SetIsRootClass(true); cm.MapMember(m => m.Id); cm.MapMember(m => m.Name); }); BsonClassMap.RegisterClassMap <SeatState>(cm => { cm.MapCreator(c => new SeatState(c.Id, c.Name)); }); var client = new MongoClient(connectionString); var database = client.GetDatabase("CqrsMovie_Seats_ReadModel"); //Best to inject a class with all parameter and not being coupled like this return(database); }); services.AddScoped <IPersister, Persister>(); services.AddSingleton <IEventStorePositionRepository>(x => new EventStorePositionRepository(x.GetService <ILogger <EventStorePositionRepository> >(), connectionString)); return(services); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { BsonClassMap.RegisterClassMap <Blog>(x => { x.AutoMap(); x.SetIgnoreExtraElements(true); x.MapIdMember(y => y.Id); }); BsonClassMap.RegisterClassMap <Post>(x => { x.AutoMap(); x.SetIgnoreExtraElements(true); }); BsonClassMap.RegisterClassMap <Author>(x => { x.AutoMap(); x.SetIgnoreExtraElements(true); }); services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1); }
public static void RegisterAll() { BsonClassMap.RegisterClassMap <Shape>(c => { c.SetDiscriminatorIsRequired(true); c.SetIsRootClass(true); c.AddKnownType(typeof(Cuboid)); }); BsonSerializer.RegisterSerializer(new SlotSerializer()); BsonSerializer.RegisterSerializer(new DependencyObjectStateSerializer()); BsonSerializer.RegisterSerializer(new BlockChunkPosSerializer()); BsonSerializer.RegisterSerializer(new BlockWorldPosSerializer()); BsonSerializer.RegisterSerializer(new ChunkWorldPosSerializer()); BsonSerializer.RegisterSerializer(new BlockSectionPosSerializer()); BsonSerializer.RegisterSerializer(new EntityWorldPosSerializer()); BsonSerializer.RegisterSerializer(new EntityChunkPosSerializer()); BsonSerializer.RegisterSerializer(new Point3dSerializer()); BsonSerializer.RegisterSerializer(new SizeSerializer()); BsonSerializer.RegisterSerializer(new ChunkColumnCompactStorageSerializer()); BsonSerializer.RegisterSerializer(new ChunkSectionCompactStorageSerializer()); BsonSerializer.RegisterSerializer(new GameModeSerializer()); }
private void RegisterIdGenerator() { BsonSerializer.RegisterIdGenerator(typeof(string), StringObjectIdGenerator.Instance); BsonSerializer.RegisterSerializer(typeof(DateTime), DateTimeStringSerializer.Instance); BsonClassMap.RegisterClassMap <NodeBase>(entity => { entity.AutoMap(); //entity.UnmapProperty(c => c.ChangeSetId); entity.UnmapProperty(c => c.Srid); entity.UnmapProperty(c => c.User); entity.UnmapProperty(c => c.UserId); entity.UnmapProperty(c => c.Visible); //entity.UnmapProperty(c => c.TimeStamp); }); BsonClassMap.RegisterClassMap <Node>(entity => { entity.AutoMap(); entity.UnmapProperty(c => c.Latitude); entity.UnmapProperty(c => c.Longtitude); }); }
private static void Map() { if (BsonClassMap.GetRegisteredClassMaps().Any()) { return; } foreach (var type in TyperConfigurarion.Typers) { var map = new BsonClassMap(type); map.AutoMap(); map.SetIsRootClass(true); //map. //map.IdMemberMap.SetIdGenerator(BsonObjectIdGenerator.Instance); //map.IdMemberMap.SetIdGenerator() BsonClassMap.RegisterClassMap(map); //type.Assembly.GetTypes() // .Where(type => featureType.IsAssignableFrom(type)).ToList() // .ForEach(type => cm.AddKnownType(type)); } }
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 MongoDbContextModel Build() { lock (SyncObj) { var entityModels = _entityModelBuilders .Select(x => x.Value) .Cast <IMongoEntityModel>() .ToImmutableDictionary(x => x.EntityType, x => x); var baseClasses = new List <Type>(); foreach (var entityModel in entityModels.Values) { var map = entityModel.As <IHasBsonClassMap>().GetMap(); if (!BsonClassMap.IsClassMapRegistered(map.ClassType)) { BsonClassMap.RegisterClassMap(map); } baseClasses.AddRange(entityModel.EntityType.GetBaseClasses(includeObject: false)); } baseClasses = baseClasses.Distinct().ToList(); foreach (var baseClass in baseClasses) { if (!BsonClassMap.IsClassMapRegistered(baseClass)) { var map = new BsonClassMap(baseClass); map.ConfigurePlusConventions(); BsonClassMap.RegisterClassMap(map); } } return(new MongoDbContextModel(entityModels)); } }