public void Set() { var pack = new ConventionPack {new CamelCaseElementNameConvention()}; ConventionRegistry.Register( "My Custom Conventions", pack, t => t.FullName.StartsWith("Foodie.")); }
public void TestSave() { var server = LegacyTestConfiguration.Server; var database = LegacyTestConfiguration.Database; var collection = LegacyTestConfiguration.GetCollection<Foo>(); var conventions = new ConventionPack(); conventions.Add(new NamedIdMemberConvention(new[] { "FooId" })); ConventionRegistry.Register("test", conventions, t => t == typeof(Foo)); BsonClassMap.RegisterClassMap<Foo>(); collection.RemoveAll(); for (int i = 0; i < 10; i++) { var foo = new Foo { FooId = ObjectId.Empty, Name = string.Format("Foo-{0}", i), Summary = string.Format("Summary for Foo-{0}", i) }; collection.Save(foo); var count = collection.Count(); Assert.AreEqual(i + 1, count); } }
static void Poco(string[] args) { var conventionPack = new ConventionPack(); conventionPack.Add(new CamelCaseElementNameConvention()); ConventionRegistry.Register("camelCase", conventionPack, t => true); BsonClassMap.RegisterClassMap<Person>(cm => { cm.AutoMap(); cm.MapMember(x => x.Name).SetElementName("name"); }); var person = new Person { Name = "Jones", Age = 30, Colors = new List<string> { "red", "blue" }, Pets = new List<Pet> { new Pet { Name = "Fluffy", Type = "Pig" } }, ExtraElements = new BsonDocument("anotherName", "anotherValue") }; using (var writer = new JsonWriter(Console.Out)) { BsonSerializer.Serialize(writer, person); } }
private static void InitializeSerialization() { var conventions = new ConventionPack(); conventions.Add(new EmptyGuidDefaultValueConvention()); conventions.Add(new IgnoreIfDefaultConvention(true)); ConventionRegistry.Register("CSharp310", conventions, type => type.FullName.StartsWith("MongoDB.Bson.Tests.Jira.CSharp310Tests", StringComparison.Ordinal)); }
// constructors static LeadsDatabase() { // register the conventions var pack = new ConventionPack { new EnumRepresentationConvention(BsonType.String) }; ConventionRegistry.Register("conventions", pack, t => true); }
public void SetUp() { var stopwatch = new Stopwatch(); _pack = new ConventionPack(); _pack.AddRange(new IConvention[] { new TrackingBeforeConvention(stopwatch) { Name = "1" }, new TrackingMemberConvention(stopwatch) { Name = "3" }, new TrackingAfterConvention(stopwatch) { Name = "5" }, new TrackingMemberConvention(stopwatch) { Name = "4" }, new TrackingAfterConvention(stopwatch) { Name = "6" }, new TrackingBeforeConvention(stopwatch) { Name = "2" }, }); _subject = new ConventionRunner(_pack); var classMap = new BsonClassMap<TestClass>(cm => { cm.MapMember(t => t.Prop1); cm.MapMember(t => t.Prop2); }); stopwatch.Start(); _subject.Apply(classMap); stopwatch.Stop(); }
//private static bool _usePBSerializationProvider_v2 = true; //public static bool UsePBSerializationProvider_v2 { get { return _usePBSerializationProvider_v2; } set { _usePBSerializationProvider_v2 = value; } } // set mongo serialization options : save enum as string public static void SetDefaultMongoSerializationOptions() { // enum as string, ATTENTION vérifier d'abord ConventionPack conventions = new ConventionPack(); conventions.Add(new EnumRepresentationConvention(BsonType.String)); ConventionRegistry.Register("PB_EnumRepresentationConvention", conventions, t => true); }
public static void RegisterConventions() { var pack = new ConventionPack { new EnumRepresentationConvention(BsonType.String) }; ConventionRegistry.Register("EnumStringConvention", pack, t => true); }
private IMongoDatabase ConnectDB() { var mongoSection = Configuration.GetSection("MongoDB"); var client = new MongoClient(mongoSection.GetSection("ConnectionString").Value); var pack = new ConventionPack(); pack.Add(new CamelCaseElementNameConvention()); ConventionRegistry.Register("camel case", pack, t => true); return client.GetDatabase(mongoSection.GetSection("Database").Value); }
private void ConfigureConvention() { var pack = new ConventionPack(); pack.Add(new CamelCaseElementNameConvention()); ConventionRegistry.Register("camelCaseConvention", pack, x => x.FullName.StartsWith("medis.Api.Models")); }
private static void RegisterConventionsImpl() { var pack = new ConventionPack { new CamelCaseElementNameConvention(), new IgnoreIfNullConvention(false) }; ConventionRegistry.Register("all", pack, type => true); }
// constructors static AssetViewDatabase() { // register the conventions var pack = new ConventionPack { new CamelCaseElementNameConvention(), new EnumRepresentationConvention(BsonType.String) }; ConventionRegistry.Register("conventions", pack, t => true); }
public DistrictsRepository(IMongoClient client, string database) { // todo: move this out to IOC config var cp = new ConventionPack(); cp.Add(new CamelCaseElementNameConvention()); ConventionRegistry.Register("camel case", cp, x => true); _client = client; _db = _client.GetDatabase(database); _collection = _db.GetCollection<District>("districts"); }
public void TestMappingUsesMemberSerializationOptionsConventionDoesNotMatchWrongProperty() { var pack = new ConventionPack(); pack.Add(new MemberSerializationOptionsConvention(typeof(ObjectId), new RepresentationSerializationOptions(BsonType.JavaScriptWithScope))); ConventionRegistry.Register("test", pack, t => t == typeof(A)); var classMap = new BsonClassMap<A>(cm => cm.AutoMap()); var options = classMap.GetMemberMap("NoMatch").SerializationOptions; Assert.IsNull(options); }
public void TestMappingUsesMemberDefaultValueConventionDoesNotMatchWrongProperty() { var pack = new ConventionPack(); pack.Add(new MemberDefaultValueConvention(typeof(int), 1)); ConventionRegistry.Register("test", pack, t => t == typeof(A)); var classMap = new BsonClassMap<A>(cm => cm.AutoMap()); var defaultValue = classMap.GetMemberMap("NoMatch").DefaultValue; Assert.Equal(0L, defaultValue); }
/// <summary> /// Sets MongoDb global Conventions /// /// This method should be called only once on startup /// </summary> /// <param name="conventions"></param> public virtual void SetConventions(IEnumerable<IConvention> conventions = null) { // Map global convention to all serialization var pack = new ConventionPack(); pack.Add(new IgnoreExtraElementsConvention(true)); if (conventions != null) pack.AddRange(conventions); ConventionRegistry.Register("ApplicationConventions", pack, t => true); }
public async Task InstallDatabase() { var mongoConventions = new ConventionPack(); mongoConventions.Add(new CamelCaseElementNameConvention()); mongoConventions.Add(new IgnoreExtraElementsConvention(true)); mongoConventions.Add(new StringEnumConvention()); ConventionRegistry.Register("camel case", mongoConventions, t => true); BsonDefaults.GuidRepresentation = GuidRepresentation.Standard; var mongoClient = new MongoClient(_connectionString); var database = mongoClient.GetDatabase(_databaseName); await RunMigrations(database); }
public void TestMappingUsesMemberDefaultValueConvention() { var pack = new ConventionPack(); pack.Add(new MemberDefaultValueConvention(typeof(int), 1)); ConventionRegistry.Register("test", pack, t => t == typeof(A)); var classMap = new BsonClassMap<A>(cm => cm.AutoMap()); var defaultValue = classMap.GetMemberMap("Match").DefaultValue; Assert.IsInstanceOf<int>(defaultValue); Assert.AreEqual(1, defaultValue); }
public void TestMappingUsesMemberSerializationOptionsConventionDoesNotOverrideAttribute() { var pack = new ConventionPack(); pack.Add(new MemberSerializationOptionsConvention(typeof(ObjectId), new RepresentationSerializationOptions(BsonType.JavaScriptWithScope))); ConventionRegistry.Register("test", pack, t => t == typeof(B)); var classMap = new BsonClassMap<B>(cm => cm.AutoMap()); var options = classMap.GetMemberMap("Match").SerializationOptions; Assert.IsInstanceOf<RepresentationSerializationOptions>(options); Assert.AreEqual(BsonType.ObjectId, ((RepresentationSerializationOptions)options).Representation); }
public void TestMappingUsesMemberDefaultValueConventionDoesNotOverrideAttribute() { var pack = new ConventionPack(); pack.Add(new MemberDefaultValueConvention(typeof(int), 1)); ConventionRegistry.Register("test", pack, t => t == typeof(B)); var classMap = new BsonClassMap<B>(cm => cm.AutoMap()); var defaultValue = classMap.GetMemberMap("Match").DefaultValue; Assert.IsType<int>(defaultValue); Assert.Equal(2, defaultValue); }
public IMongoDatabaseBuilder RegisterDefaultConventionPack() { var conventionPack = new ConventionPack { new EnumRepresentationConvention(BsonType.String), new ImmutableConvention(), new IgnoreExtraElementsConvention(true) }; RegisterConventionPack("Default", conventionPack, t => true); return(this); }
public MongoEventStore(IConfiguration configuration, IMongoClient mongoClient) { _databaseName = configuration["Mongo:DatabaseName"] ?? "EventStore"; var conventionPack = new ConventionPack { new MapReadOnlyPropertiesConvention() }; ConventionRegistry.Register("Conventions", conventionPack, _ => true); _mongoClient = mongoClient; }
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv) { // configuration var builder = new ConfigurationBuilder(appEnv.ApplicationBasePath) .AddJsonFile("config.json") .AddJsonFile($"config.{env.EnvironmentName}.json", optional: true); builder.AddEnvironmentVariables(); Configuration = builder.Build(); // MongoDB objects attributes naming conventions var conventionPack = new ConventionPack(); conventionPack.Add(new CamelCaseElementNameConvention()); ConventionRegistry.Register("CamelCase", conventionPack, t => true); }
static AbstractRepository() { var pack = new ConventionPack(); var ignoreIfNull = new IgnoreIfNullConvention(true); pack.Add(ignoreIfNull); ConventionRegistry.Register("ignoreNulls", pack, t => true); Migrations.CreatePointsOfInterest(); Migrations.CreateUsers(); Migrations.EnsureGeospacialIndex(); Migrations.EnsureUniqueEmailIndex(); Migrations.CreateLocationTypes(); }
public void TestMappingUsesMemberDefaultValueConventionDoesNotMatchWrongProperty() { var pack = new ConventionPack(); pack.Add(new MemberDefaultValueConvention(typeof(int), 1)); ConventionRegistry.Register("test", pack, t => t == typeof(A)); var classMap = new BsonClassMap <A>(cm => cm.AutoMap()); var defaultValue = classMap.GetMemberMap("NoMatch").DefaultValue; Assert.AreEqual(0, defaultValue); }
private static void SetupConventions() { if (isConventionSetup) { return; } var enumConventionPack = new ConventionPack { new EnumRepresentationConvention(BsonType.String) }; ConventionRegistry.Register("EnumSerializationConvention", enumConventionPack, t => t.IsEnum); isConventionSetup = true; }
public MongoDbService(MongoClientSettings settings, string databaseName) { ConventionPack conventionPack = new ConventionPack { new CamelCaseElementNameConvention() }; ConventionRegistry.Register("camelCase", conventionPack, t => true); MongoClient client = new MongoClient(settings); IMongoDatabase database = client.GetDatabase(databaseName); users = new UserCollection(database.GetCollection <UserModel>("users")); }
public static void Init() { var pack = new ConventionPack(); pack.Add(new CamelCaseElementNameConvention()); ConventionRegistry.Register("CamelCase", pack, t => t.FullName.StartsWith("MongoDB.Migrations.Tool.Entity.")); BsonClassMap.RegisterClassMap <Book>(cm => { cm.AutoMap(); cm.SetIgnoreExtraElements(true); }); }
public void TestMappingUsesMemberSerializationOptionsConventionDoesNotMatchWrongProperty() { var pack = new ConventionPack(); pack.Add(new MemberSerializationOptionsConvention(typeof(ObjectId), new RepresentationSerializationOptions(BsonType.JavaScriptWithScope))); ConventionRegistry.Register("test", pack, t => t == typeof(A)); var classMap = new BsonClassMap <A>(cm => cm.AutoMap()); var options = classMap.GetMemberMap("NoMatch").SerializationOptions; Assert.IsNull(options); }
private void RegisterConventions() { var pack = new ConventionPack(); pack.Add(new EnumRepresentationConvention(BsonType.Int32)); pack.Add(new IgnoreIfNullConvention(true)); pack.Add(new IgnoreIfDefaultConvention(false)); Assembly entitiesAssembly = typeof(Post).GetTypeInfo().Assembly; ConventionRegistry.Register("MongoDbSpecs pack", pack, t => t.GetTypeInfo().Assembly == entitiesAssembly); }
public void Setup() { var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() }; ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true); var client = new MongoClient(Constants.MongoDbConnectionUri()); _moviesCollection = client.GetDatabase("sample_mflix").GetCollection <Movie>("movies"); _commentsCollection = client.GetDatabase("sample_mflix").GetCollection <Comment>("comments"); }
static ArticlesContext() { // Conventions var managedTypes = new HashSet <Type> { typeof(Article) }; var conventions = new ConventionPack(); conventions.Add(new GuidRepresentationConvention(BsonType.String)); ConventionRegistry.Register("ManagedTypeConventions", conventions, managedTypes.Contains); }
/// <summary> /// Registers the MongoDB Bson serialization conventions. /// </summary> /// <param name="autoGenerateID">A <see cref="Boolean"/> value which indicates whether /// the ID value should be automatically generated when a new document is inserting.</param> /// <param name="localDateTime">A <see cref="Boolean"/> value which indicates whether /// the local date/time should be used when serializing/deserializing <see cref="DateTime"/> values.</param> /// <param name="additionConventions">Additional conventions that needs to be registered.</param> public static void RegisterConventions(bool autoGenerateID, bool localDateTime, IEnumerable<IConvention> additionConventions) { var conventionPack = new ConventionPack(); conventionPack.Add(new NamedIdMemberConvention("id", "Id", "ID", "iD")); if (autoGenerateID) conventionPack.Add(new GuidIDGeneratorConvention()); if (localDateTime) conventionPack.Add(new UseLocalDateTimeConvention()); if (additionConventions != null) conventionPack.AddRange(additionConventions); ConventionRegistry.Register("DefaultConvention", conventionPack, t => true); }
public CommentsRepository(IMongoClient mongoClient) { var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() }; ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true); _commentsCollection = mongoClient.GetDatabase("sample_mflix").GetCollection <Comment>("comments"); _moviesRepository = new MoviesRepository(mongoClient); _userRepository = new UsersRepository(mongoClient); }
private void AddFilters(HttpConfiguration config) { config.Filters.Add(new ModelValidationFilterAttribute()); config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); var pack = new ConventionPack { new CamelCaseElementNameConvention() }; ConventionRegistry.Register("camelCaseFields", pack, t => true); }
public MysteryMongoDb() { //we apply our conventions //enums shall became string var pack = new ConventionPack { new EnumRepresentationConvention(BsonType.String), new IgnoreExtraElementsConvention(ignoreExtraElements: true), }; ConventionRegistry.Register("MysteryConvetions", pack, t => true); BsonSerializer.RegisterSerializer(typeof(DateTime), DateTimeSerializer.LocalInstance); }
/// <summary> /// Instala os mapeamentos dos modelos para o MongoDB /// </summary> public static void Install() { // Define como Camel Case o nome das chaves de cada registro no banco de dados ConventionPack conventionPack = new ConventionPack { new CamelCaseElementNameConvention() }; ConventionRegistry.Register("camelCase", conventionPack, t => true); AuctionMap.Configure(); AuctionResponsibleUserMap.Configure(); UserMap.Configure(); }
public static Bootstrapper UseMongoDbAsMainRepository(this Bootstrapper bootstrapper, MongoDbOptions options) { if (options == null) { throw new ArgumentNullException(nameof(options)); } var service = new MongoDbDALBootstrapperService { BootstrappAction = (ctx) => { if (BsonSerializer.SerializerRegistry.GetSerializer <Type>() == null) { BsonSerializer.RegisterSerializer(typeof(Type), new TypeSerializer()); } if (BsonSerializer.SerializerRegistry.GetSerializer <Guid>() == null) { BsonSerializer.RegisterSerializer(typeof(Guid), new GuidSerializer()); } MongoDbContext.DatabaseName = options.DatabaseName; MongoDbContext.MongoClient = new MongoDB.Driver.MongoClient(options.Url); var pack = new ConventionPack(); pack.Add(new IgnoreExtraElementsConvention(true)); ConventionRegistry.Register("CQELight conventions", pack, _ => true); if (ctx.IsServiceRegistered(BootstrapperServiceType.IoC)) { bootstrapper.AddIoCRegistration(new TypeRegistration <MongoDataReaderAdapter>(true)); bootstrapper.AddIoCRegistration(new TypeRegistration <MongoDataWriterAdapter>(true)); var entities = ReflectionTools.GetAllTypes() .Where(t => typeof(IPersistableEntity).IsAssignableFrom(t)).ToList(); foreach (var item in entities) { var mongoRepoType = typeof(MongoRepository <>).MakeGenericType(item); var dataReaderRepoType = typeof(IDataReaderRepository <>).MakeGenericType(item); var databaseRepoType = typeof(IDatabaseRepository <>).MakeGenericType(item); var dataUpdateRepoType = typeof(IDataUpdateRepository <>).MakeGenericType(item); bootstrapper .AddIoCRegistration(new FactoryRegistration(() => mongoRepoType.CreateInstance(), mongoRepoType, dataUpdateRepoType, databaseRepoType, dataReaderRepoType)); } } } }; bootstrapper.AddService(service); return(bootstrapper); }
// public static methods /// <summary> /// Looks up the effective set of conventions that apply to a type. /// </summary> /// <param name="type">The type.</param> /// <returns>The conventions for that type.</returns> public static IConventionPack Lookup(Type type) { if (type == null) { throw new ArgumentNullException("type"); } lock (__lock) { var pack = new ConventionPack(); // append any attribute packs (usually just one) at the end so attributes are processed last var attributePacks = new List<IConventionPack>(); #pragma warning disable 618 //obsoleted by ConventionProfile ConventionProfile conventionProfile = null; #pragma warning restore 618 foreach (var container in __conventionPacks) { if (container.Filter(type)) { #pragma warning disable 618 //obsoleted by ConventionProfile if (container.Pack is ConventionProfile) { conventionProfile = container.Pack as ConventionProfile; } #pragma warning restore 618 if (container.Name == "__attributes__") { attributePacks.Add(container.Pack); } else { pack.Append(container.Pack); } } } if (conventionProfile != null) { // already includes the default attribute convention pack return conventionProfile; } foreach (var attributePack in attributePacks) { pack.Append(attributePack); } return pack; } }
static MongoEventStoreTests() { var pack = new ConventionPack { new CamelCaseElementNameConvention(), new IgnoreExtraElementsConvention(true) }; ConventionRegistry.Register("camelCase", pack, t => true); BsonSerializer.RegisterSerializer(typeof(DateTime), DateTimeSerializer.LocalInstance); BsonDefaults.GuidRepresentation = GuidRepresentation.Standard; }
static void Setup() { var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() }; ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true); var mongoUri = mongoConnectionString; var mflixClient = new MongoClient(mongoUri); var moviesDatabase = mflixClient.GetDatabase("sample_mflix"); _moviesCollection = moviesDatabase.GetCollection <Movie>("movies"); }
protected virtual void RegisterConventions() { var pack = new ConventionPack(); pack.Add(new EnumRepresentationConvention(BsonType.Int32)); pack.Add(new IgnoreIfNullConvention(true)); pack.Add(new IgnoreIfDefaultConvention(false)); Assembly thisAssembly = typeof(IdentityMongoDbContext <>).GetTypeInfo().Assembly; ConventionRegistry.Register("Identity custom pack", pack, t => t.GetTypeInfo().Assembly == thisAssembly); }
public static void Init() { var pack = new ConventionPack { new CamelCaseElementNameConvention() }; ConventionRegistry.Register( "CamelCaseElementNameConvention", pack, t => true); EntityMapperInitializer.Init(); }
private static void Register() { var conventionPack = new ConventionPack { new IgnoreExtraElementsConvention(true) }; ConventionRegistry.Register("IgnoreElements", conventionPack, type => true); if (!_isRegistered) { BsonSerializer.RegisterSerializer(typeof(DateTime), new UtcDateTimeSerializer()); _isRegistered = true; } }
public void TestMappingUsesMemberSerializationOptionsConventionDoesNotOverrideAttribute() { var pack = new ConventionPack(); pack.Add(new MemberSerializationOptionsConvention(typeof(ObjectId), new RepresentationSerializationOptions(BsonType.JavaScriptWithScope))); ConventionRegistry.Register("test", pack, t => t == typeof(B)); var classMap = new BsonClassMap <B>(cm => cm.AutoMap()); var options = classMap.GetMemberMap("Match").SerializationOptions; Assert.IsInstanceOf <RepresentationSerializationOptions>(options); Assert.AreEqual(BsonType.ObjectId, ((RepresentationSerializationOptions)options).Representation); }
public void Init() { var user = EnvironmentConstants.MONGO_DB_USER.GetAsMandatoryEnvironmentVariable(); var password = EnvironmentConstants.MONGO_DB_PASSWORD.GetAsMandatoryEnvironmentVariable(); _client = new MongoClient($"mongodb://{user}:{password}@mongo"); _database = _client.GetDatabase("propertyCrawler"); var pack = new ConventionPack { new IgnoreExtraElementsConvention(true) }; ConventionRegistry.Register("My Solution Conventions", pack, t => true); }
public IMongoDatabase GetDatabase() { var url = new MongoUrl(_configuration.GetConnectionString("Mongo")); var client = new MongoClient(url); var database = client.GetDatabase("HumanResources"); var conventionPack = new ConventionPack { new IgnoreExtraElementsConvention(true) }; ConventionRegistry.Register("IgnoreExtraElements", conventionPack, x => true); return(database); }
public void Setup() { var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() }; ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true); var client = new MongoClient(Constants.MongoDbConnectionUri()); _theatersCollection = client.GetDatabase("sample_mflix").GetCollection <Theater>("theaters"); AddTestTheaters(); }
public void TestMappingUsesMemberDefaultValueConventionDoesNotOverrideAttribute() { var pack = new ConventionPack(); pack.Add(new MemberDefaultValueConvention(typeof(int), 1)); ConventionRegistry.Register("test", pack, t => t == typeof(B)); var classMap = new BsonClassMap <B>(cm => cm.AutoMap()); var defaultValue = classMap.GetMemberMap("Match").DefaultValue; Assert.IsType <int>(defaultValue); Assert.Equal(2, defaultValue); }
/// <summary> /// Sets MongoDb global Conventions /// /// This method should be called only once on startup /// </summary> /// <param name="conventions"></param> public virtual void SetConventions(IEnumerable <IConvention> conventions = null) { // Map global convention to all serialization var pack = new ConventionPack(); pack.Add(new IgnoreExtraElementsConvention(true)); if (conventions != null) { pack.AddRange(conventions); } ConventionRegistry.Register("ApplicationConventions", pack, t => true); }
public static void ForType <T>(string idPropName) { var t = typeof(T); lock (_done) { if (_done.Add(t)) { var cp = new ConventionPack(); cp.AddClassMapConvention(t.Name + "ids", bcm => bcm.MapIdProperty(idPropName)); ConventionRegistry.Register(t.Name + "idsPack", cp, type => type == t); } } }
public static IServiceCollection WithMongo(this IServiceCollection services, IConfiguration configuration) { services.Configure <MongoSettings>(configuration.GetSection("MongoSettings")); var pack = new ConventionPack { new IgnoreExtraElementsConvention(true) }; ConventionRegistry.Register("My Solution Conventions", pack, t => true); BaseModelConfiguration.Configure(); return(services); }
static CSharp648Tests() { // suppressing the _id by registering the class map manually BsonClassMap.RegisterClassMap<U2>(cm => { cm.AutoMap(); cm.SetIdMember(null); }); // suppressing the _id by using the NoIdMemberConvention var pack = new ConventionPack(); pack.Add(new NoIdMemberConvention()); ConventionRegistry.Register("U3noid", pack, t => t == typeof(U3)); }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); GlobalConfiguration.Configure(WebApiConfig.Register); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); var pack = new ConventionPack() { new EnumRepresentationConvention(BsonType.String) }; ConventionRegistry.Register("EnumStringConvention", pack, t => true); }
internal void RegisterMongoDbConventions() { var appConventions = new ConventionPack { new IgnoreExtraElementsConvention(true), new EnumRepresentationConvention(BsonType.String), new NamedIdMemberConvention("Id"), }; BsonClassMap.RegisterClassMap<EventMetadata>(); ConventionRegistry.Register("Core", appConventions, type => true); BsonSerializer.RegisterSerializer(typeof(DateTime), new DateTimeSerializer(new DateTimeSerializationOptions(DateTimeKind.Utc))); BsonSerializer.RegisterSerializer(typeof(DateTime?), new NullableSerializer<DateTime>()); }
private void InitializeDatabase(string connectionString) { // Specify, that null values should be ignored by BsonSerializer var p = new ConventionPack { new IgnoreIfNullConvention(true), new IgnoreExtraElementsConvention(true) }; ConventionRegistry.Register("all", p, t => true); var urlBuilder = new MongoUrlBuilder(connectionString); dbPrefix = urlBuilder.DatabaseName; if (string.IsNullOrWhiteSpace(dbPrefix)) throw new ArgumentException("Connection string must include database name prefix. E.g. mongodb://mongodb01/staging"); mongoClient = new MongoClient(connectionString); mongoServer = mongoClient.GetServer(); }
static async Task classBarmoloMetodusConventionPack() { var conventionPack = new ConventionPack(); conventionPack.Add(new CamelCaseElementNameConvention()); ConventionRegistry.Register("camelCase", conventionPack, t => true); var person = new Person { Name = "Jones", Age = 34, //Colors = new List<string> { "red", "green" }, //Pets = new List<Pet> { new Pet { Name = "Fluffy", Type = "Pig" } }, //ExtraElements = new BsonDocument("anotherName", "anotherValue") }; using (var writer = new JsonWriter(Console.Out)) { BsonSerializer.Serialize(writer, person); } }
public MongoContext() { var pack = new ConventionPack() { new CamelCaseElementNameConvention(), new EnumRepresentationConvention(BsonType.String) }; ConventionRegistry.Register("CamelCaseConvensions", pack, t => true); var mongoUrlBuilder = new MongoUrlBuilder(ConfigurationManager.ConnectionStrings["AuthContext"].ConnectionString); var mongoClient = new MongoClient(mongoUrlBuilder.ToMongoUrl()); var server = mongoClient.GetServer(); Database = server.GetDatabase(mongoUrlBuilder.DatabaseName); userCollection = Database.GetCollection<User>("users"); roleCollection = Database.GetCollection<Role>("roles"); clientCollection = Database.GetCollection<Client>("clients"); refreshTokenCollection = Database.GetCollection<RefreshToken>("refreshTokens"); }
protected BaseTest() { // http://stackoverflow.com/questions/19521626/mongodb-convention-packs ConventionPack conventionPack = new ConventionPack { new CamelCaseElementNameConvention() }; ConventionRegistry.Register("camelCase", conventionPack, x => true); string connectionString = String.Format("mongodb://{0}:{1}", MongoServerAddress, MongoServerPort); var mongoClient = new MongoClient(connectionString); BlogContext = new BlogContext(mongoClient); Task blogContextResetDataTask = BlogContext.ResetData(); SchoolContext = new SchoolContext(mongoClient); Task schoolContextResetDataTask = SchoolContext.ResetData(); TestContext = new TestContext(mongoClient); Task testContextResetDataTask = TestContext.ResetData(); testContextResetDataTask.Wait(); blogContextResetDataTask.Wait(); schoolContextResetDataTask.Wait(); }