public void TestConstructorArgumentChecking() { var settings = new MongoCollectionSettings<BsonDocument>(_database, ""); Assert.Throws<ArgumentNullException>(() => { new MongoCollection<BsonDocument>(null, settings); }); Assert.Throws<ArgumentNullException>(() => { new MongoCollection<BsonDocument>(_database, null); }); Assert.Throws<ArgumentOutOfRangeException>(() => { new MongoCollection<BsonDocument>(_database, settings); }); }
public void TestAll() { var settings = new MongoCollectionSettings(); settings.CollectionName = "collection"; settings.AssignIdOnInsert = false; settings.SafeMode = SafeMode.Create(5, TimeSpan.FromSeconds(5)); settings.SlaveOk = true; Assert.AreEqual("collection", settings.CollectionName); Assert.AreEqual(false, settings.AssignIdOnInsert); Assert.AreEqual(SafeMode.Create(5, TimeSpan.FromSeconds(5)), settings.SafeMode); Assert.AreEqual(true, settings.SlaveOk); Assert.IsFalse(settings.IsFrozen); var hashCode = settings.GetHashCode(); var stringRepresentation = settings.ToString(); Assert.AreEqual(settings, settings); settings.Freeze(); Assert.IsTrue(settings.IsFrozen); Assert.AreEqual(hashCode, settings.GetHashCode()); Assert.AreEqual(stringRepresentation, settings.ToString()); var clone = settings.Clone(); Assert.IsFalse(clone.IsFrozen); Assert.AreEqual(settings, clone); }
public static MongoCollectionSettings CollectionSettings() { var collectionSettings = new MongoCollectionSettings(); collectionSettings.WriteConcern = WriteConcern.WMajority; return collectionSettings; }
public void TestAll() { var settings = new MongoCollectionSettings<BsonDocument>( "collection", true, // asssignIdOnInsert SafeMode.Create(5, TimeSpan.FromSeconds(5)), true // slaveOkd ); Assert.AreEqual("collection", settings.CollectionName); Assert.AreEqual(true, settings.AssignIdOnInsert); Assert.AreEqual(typeof(BsonDocument), settings.DefaultDocumentType); Assert.AreEqual(SafeMode.Create(5, TimeSpan.FromSeconds(5)), settings.SafeMode); Assert.AreEqual(true, settings.SlaveOk); Assert.IsFalse(settings.IsFrozen); var hashCode = settings.GetHashCode(); var stringRepresentation = settings.ToString(); Assert.AreEqual(settings, settings); settings.Freeze(); Assert.IsTrue(settings.IsFrozen); Assert.AreEqual(hashCode, settings.GetHashCode()); Assert.AreEqual(stringRepresentation, settings.ToString()); }
public void TestFixtureSetup() { _database = Configuration.TestDatabase; var collectionSettings = new MongoCollectionSettings() { GuidRepresentation = GuidRepresentation.Standard }; _collection = _database.GetCollection<C>("csharp714", collectionSettings); _collection.Drop(); }
public void TestEquals() { var settings = new MongoCollectionSettings(); var clone = settings.Clone(); Assert.IsTrue(clone.Equals(settings)); settings.Freeze(); clone.Freeze(); Assert.IsTrue(clone.Equals(settings)); clone = settings.Clone(); clone.AssignIdOnInsert = !clone.AssignIdOnInsert; Assert.IsFalse(clone.Equals(settings)); clone = settings.Clone(); clone.GuidRepresentation = GuidRepresentation.PythonLegacy; Assert.IsFalse(clone.Equals(settings)); clone = settings.Clone(); clone.ReadPreference = ReadPreference.Secondary; Assert.IsFalse(clone.Equals(settings)); clone = settings.Clone(); clone.WriteConcern = WriteConcern.W2; Assert.IsFalse(clone.Equals(settings)); }
public CSharp714Tests() { _database = LegacyTestConfiguration.Database; var collectionSettings = new MongoCollectionSettings() { GuidRepresentation = GuidRepresentation.Standard }; _collection = _database.GetCollection<C>("csharp714", collectionSettings); _collection.Drop(); }
public void TestAll() { var server = MongoServer.Create(); var database = server["test"]; var settings = new MongoCollectionSettings<BsonDocument>(database, "collection") { AssignIdOnInsert = true, SafeMode = SafeMode.Create(5, TimeSpan.FromSeconds(5)), SlaveOk = true }; Assert.AreEqual("collection", settings.CollectionName); Assert.AreEqual(true, settings.AssignIdOnInsert); Assert.AreEqual(typeof(BsonDocument), settings.DefaultDocumentType); Assert.AreEqual(GuidRepresentation.CSharpLegacy, settings.GuidRepresentation); Assert.AreEqual(SafeMode.Create(5, TimeSpan.FromSeconds(5)), settings.SafeMode); Assert.AreEqual(true, settings.SlaveOk); Assert.IsFalse(settings.IsFrozen); var hashCode = settings.GetHashCode(); var stringRepresentation = settings.ToString(); Assert.AreEqual(settings, settings); settings.Freeze(); Assert.IsTrue(settings.IsFrozen); Assert.AreEqual(hashCode, settings.GetHashCode()); Assert.AreEqual(stringRepresentation, settings.ToString()); }
public void TestConstructor() { var settings = new MongoCollectionSettings(); Assert.AreEqual(false, settings.AssignIdOnInsert); Assert.AreEqual(GuidRepresentation.Unspecified, settings.GuidRepresentation); Assert.AreEqual(null, settings.ReadPreference); Assert.AreEqual(null, settings.WriteConcern); }
public MongoEventStore(MongoClient client) { if (client == null) throw new ArgumentNullException("client"); this.client = client; BsonClassMap.RegisterClassMap<MongoEventDocument>(); _commitSettings = new MongoCollectionSettings {AssignIdOnInsert = false, WriteConcern = WriteConcern.Acknowledged}; }
/// <summary> /// Opens connection to MongoDB Server /// </summary> public MongoTransitionServer(String connectionString, String collectionName) { _collectionName = collectionName; _databaseName = MongoUrl.Create(connectionString).DatabaseName; _server = MongoServer.Create(connectionString); _transitionSettings = Database.CreateCollectionSettings<BsonDocument>(_collectionName); _transitionSettings.SafeMode = SafeMode.True; _transitionSettings.AssignIdOnInsert = false; }
internal static void Init(string connectionString) { var client = new MongoClient(connectionString); IMongoDatabase database = client.GetDatabase("sqlWithMongo"); var collectionSettings = new MongoCollectionSettings { WriteConcern = new WriteConcern(1) }; _collection = database.GetCollection<NodeLinks>("links", collectionSettings); }
public MongodbCollection(MongodbDatabase database, Type documentType, String collectionName) { if (collectionName == null) throw new ArgumentNullException("collectionName"); _database = database; _documentType = documentType; _collectionName = collectionName; _metadata = _database.UniformDatabase.Metadata; var mongoSettings = new MongoCollectionSettings {AssignIdOnInsert = false}; _collection = _database.Database.GetCollection(documentType, _collectionName, mongoSettings); }
public void TestFrozenCopy() { var server = MongoServer.Create(); var database = server["test"]; var settings = new MongoCollectionSettings<BsonDocument>(database, "collection"); var frozenCopy = settings.FrozenCopy(); var secondFrozenCopy = frozenCopy.FrozenCopy(); Assert.AreNotSame(settings, frozenCopy); Assert.AreSame(frozenCopy, secondFrozenCopy); Assert.AreEqual(false, settings.IsFrozen); Assert.AreEqual(true, frozenCopy.IsFrozen); }
public void TestAssignIdOnInsert() { var settings = new MongoCollectionSettings<BsonDocument>(_database, "collection"); Assert.AreEqual(MongoDefaults.AssignIdOnInsert, settings.AssignIdOnInsert); var assignIdOnInsert = !settings.AssignIdOnInsert; settings.AssignIdOnInsert = assignIdOnInsert; Assert.AreEqual(assignIdOnInsert, settings.AssignIdOnInsert); settings.Freeze(); Assert.AreEqual(assignIdOnInsert, settings.AssignIdOnInsert); Assert.Throws<InvalidOperationException>(() => { settings.AssignIdOnInsert = assignIdOnInsert; }); }
public void TestClone() { // set everything to non default values to test that all settings are cloned var settings = new MongoCollectionSettings<BsonDocument>(_database, "collection") { AssignIdOnInsert = !MongoDefaults.AssignIdOnInsert, GuidRepresentation = GuidRepresentation.PythonLegacy, ReadPreference = ReadPreference.Secondary, WriteConcern = WriteConcern.W2 }; var clone = settings.Clone(); Assert.IsTrue(clone.Equals(settings)); }
public void TestAssignIdOnInsert() { var settings = new MongoCollectionSettings(); Assert.AreEqual(false, settings.AssignIdOnInsert); var assignIdOnInsert = !settings.AssignIdOnInsert; settings.AssignIdOnInsert = assignIdOnInsert; Assert.AreEqual(assignIdOnInsert, settings.AssignIdOnInsert); settings.Freeze(); Assert.AreEqual(assignIdOnInsert, settings.AssignIdOnInsert); Assert.Throws<InvalidOperationException>(() => { settings.AssignIdOnInsert = assignIdOnInsert; }); }
public void Setup() { var settings = new MongoCollectionSettings(); var dbSettings = new MongoDatabaseSettings(); dbSettings.ApplyDefaultValues(new MongoServerSettings()); settings.ApplyDefaultValues(dbSettings); _operationExecutor = new MockOperationExecutor(); _subject = new MongoCollectionImpl<BsonDocument>( new CollectionNamespace("foo", "bar"), settings, Substitute.For<ICluster>(), _operationExecutor); }
public void TestAll() { var settings = new MongoCollectionSettings { AssignIdOnInsert = true, GuidRepresentation = GuidRepresentation.PythonLegacy, ReadPreference = ReadPreference.Primary, WriteConcern = WriteConcern.Acknowledged }; Assert.AreEqual(true, settings.AssignIdOnInsert); Assert.AreEqual(GuidRepresentation.PythonLegacy, settings.GuidRepresentation); Assert.AreSame(ReadPreference.Primary, settings.ReadPreference); Assert.AreSame(WriteConcern.Acknowledged, settings.WriteConcern); }
public void TestBasic() { var server = MongoServer.Create(); var database = server["test"]; var it = new MongoCollectionSettings<Document>(database, "Document"); var items = from item in database.GetCollection(it) where item.ID == 1 select item; var count = Enumerable.Count(items); Assert.AreEqual(1, count); }
public void TestAll() { var settings = new MongoCollectionSettings<BsonDocument>(_database, "collection") { AssignIdOnInsert = true, GuidRepresentation = GuidRepresentation.PythonLegacy, ReadPreference = ReadPreference.Primary, WriteConcern = WriteConcern.Acknowledged }; Assert.AreEqual("collection", settings.CollectionName); Assert.AreEqual(typeof(BsonDocument), settings.DefaultDocumentType); Assert.AreEqual(true, settings.AssignIdOnInsert); Assert.AreEqual(GuidRepresentation.PythonLegacy, settings.GuidRepresentation); Assert.AreSame(ReadPreference.Primary, settings.ReadPreference); Assert.AreSame(WriteConcern.Acknowledged, settings.WriteConcern); }
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 database = MongoDatabase.Create(connectionString); var settings = new MongoCollectionSettings<MongoCacheItem>(database, "embedly"); _collection = database.GetCollection(settings); }
public void TestCount() { var server = MongoServer.Create(); var database = server["test"]; var it = new MongoCollectionSettings<Document>(database, "Document"); var col = database.GetCollection(it); var query = (from k in col where k.Name == "Vlad" select k); Assert.AreEqual(1, query.Count()); Assert.AreEqual(typeof(int), query.Count().GetType()); Assert.AreEqual(1, query.LongCount()); Assert.AreEqual(typeof(long), query.LongCount().GetType()); Assert.AreEqual(1, query.LongCount(k => k.ID == 1)); Assert.AreEqual(typeof(long), query.LongCount(k => k.ID == 1).GetType()); }
public void TestAdvancedWhere() { var server = MongoServer.Create(); var database = server["test"]; var it = new MongoCollectionSettings<Document>(database, "Document"); var rnd = new Random(); var items = from item in database.GetCollection(it) where item.ID == rnd.Next(0, 4) select item; var count = 0; foreach (var item in items) { count++; } Assert.AreEqual(1, count); }
public void Flush() { long tobson = 0; int index = 0; Task[] tasks = new Task[_inMemoryDatabase.Collections.Keys.Count]; foreach (var pair in _inMemoryDatabase.Collections) { var mongoSettings = new MongoCollectionSettings {AssignIdOnInsert = false}; var mongoCollection = Database.GetCollection(typeof(BsonDocument), pair.Key.CollectionName, mongoSettings); var inMemoryCollection = (IInMemoryCollection) pair.Value; var stopwatch = Stopwatch.StartNew(); var docs = BsonDocumentWrapper.CreateMultiple(inMemoryCollection.Documents.Values); stopwatch.Stop(); //Console.WriteLine("Collection {0} serialized to bson in {1:n0} ms", pair.Key, stopwatch.ElapsedMilliseconds); tobson += stopwatch.ElapsedMilliseconds; stopwatch.Start(); tasks[index] = Task.Factory.StartNew(() => { var mongoInsertOptions = new MongoInsertOptions(); mongoInsertOptions.CheckElementNames = false; mongoInsertOptions.WriteConcern = WriteConcern.Acknowledged; mongoCollection.InsertBatch(docs); }, TaskCreationOptions.LongRunning); stopwatch.Stop(); //Console.WriteLine("Collection {0} inserted to MongoDB in {1:n0} ms", pair.Key, stopwatch.ElapsedMilliseconds); index++; } Task.WaitAll(tasks); //Console.WriteLine("Total time for serialization: {0:n0} ms", tobson); }
public void TestDefaults() { var settings = new MongoCollectionSettings(); Assert.AreEqual(null, settings.CollectionName); Assert.AreEqual(true, settings.AssignIdOnInsert); Assert.AreEqual(SafeMode.False, settings.SafeMode); Assert.AreEqual(false, settings.SlaveOk); Assert.IsFalse(settings.IsFrozen); var hashCode = settings.GetHashCode(); var stringRepresentation = settings.ToString(); Assert.AreEqual(settings, settings); settings.Freeze(); Assert.IsTrue(settings.IsFrozen); Assert.AreEqual(hashCode, settings.GetHashCode()); Assert.AreEqual(stringRepresentation, settings.ToString()); var clone = settings.Clone(); Assert.IsFalse(clone.IsFrozen); Assert.AreEqual(settings, clone); }
public Tailer(IMongoClient client, MongoCollectionSettings oplogCollectionSettings = null, string oplogCollectionName = "oplog.rs") { if(client == null) { throw new ArgumentNullException("client"); } if(string.IsNullOrWhiteSpace(client.Settings.ReplicaSetName)) { throw new MongoRiverException("Mongo client is not configured as a replica set"); } if(oplogCollectionSettings == null) { oplogCollectionSettings = new MongoCollectionSettings { // You probably don't want to be doing this on your primary ReadPreference = ReadPreference.Secondary }; } m_oplogCollection = client.GetDatabase("local").GetCollection<Oplog>(oplogCollectionName, oplogCollectionSettings); }
public override IMongoCollection <TDocument> GetCollection <TDocument>(string name, MongoCollectionSettings settings) { Ensure.IsNotNullOrEmpty(name, nameof(name)); settings = settings == null ? new MongoCollectionSettings() : settings.Clone(); settings.ApplyDefaultValues(_settings); return(new MongoCollectionImpl <TDocument>(this, new CollectionNamespace(_databaseNamespace, name), settings, _cluster, _operationExecutor)); }
/// <inheritdoc /> public abstract IMongoCollection <TDocument> GetCollection <TDocument>(string name, MongoCollectionSettings settings = null);
/// <summary> /// Gets a MongoCollection instance representing a collection on this database /// with a default document type of TDefaultDocument. /// </summary> /// <typeparam name="TDefaultDocument">The default document type for this collection.</typeparam> /// <param name="collectionSettings">The settings to use when accessing this collection.</param> /// <returns>An instance of MongoCollection.</returns> public virtual MongoCollection <TDefaultDocument> GetCollection <TDefaultDocument>(MongoCollectionSettings <TDefaultDocument> collectionSettings) { lock (databaseLock) { MongoCollection collection; if (!collections.TryGetValue(collectionSettings, out collection)) { collection = new MongoCollection <TDefaultDocument>(this, collectionSettings); collections.Add(collectionSettings, collection); } return((MongoCollection <TDefaultDocument>)collection); } }
private MongoCollectionImpl(IMongoDatabase database, CollectionNamespace collectionNamespace, MongoCollectionSettings settings, ICluster cluster, IOperationExecutor operationExecutor, IBsonSerializer <TDocument> documentSerializer) { _database = Ensure.IsNotNull(database, nameof(database)); _collectionNamespace = Ensure.IsNotNull(collectionNamespace, nameof(collectionNamespace)); _settings = Ensure.IsNotNull(settings, nameof(settings)).Freeze(); _cluster = Ensure.IsNotNull(cluster, nameof(cluster)); _operationExecutor = Ensure.IsNotNull(operationExecutor, nameof(operationExecutor)); _documentSerializer = Ensure.IsNotNull(documentSerializer, nameof(documentSerializer)); _messageEncoderSettings = new MessageEncoderSettings { { MessageEncoderSettingsName.GuidRepresentation, _settings.GuidRepresentation }, { MessageEncoderSettingsName.ReadEncoding, _settings.ReadEncoding ?? Utf8Encodings.Strict }, { MessageEncoderSettingsName.WriteEncoding, _settings.WriteEncoding ?? Utf8Encodings.Strict } }; }
// constructors public MongoCollectionImpl(IMongoDatabase database, CollectionNamespace collectionNamespace, MongoCollectionSettings settings, ICluster cluster, IOperationExecutor operationExecutor) { _database = Ensure.IsNotNull(database, "database"); _collectionNamespace = Ensure.IsNotNull(collectionNamespace, "collectionNamespace"); _settings = Ensure.IsNotNull(settings, "settings").Freeze(); _cluster = Ensure.IsNotNull(cluster, "cluster"); _operationExecutor = Ensure.IsNotNull(operationExecutor, "operationExecutor"); _documentSerializer = _settings.SerializerRegistry.GetSerializer <TDocument>(); _messageEncoderSettings = new MessageEncoderSettings { { MessageEncoderSettingsName.GuidRepresentation, _settings.GuidRepresentation }, { MessageEncoderSettingsName.ReadEncoding, _settings.ReadEncoding ?? Utf8Encodings.Strict }, { MessageEncoderSettingsName.WriteEncoding, _settings.WriteEncoding ?? Utf8Encodings.Strict } }; }
public void Dispose() { _collectionSettings = null; _client = null; _db = null; }
/// <summary> /// Gets a MongoCollection instance representing a collection on this database /// with a default document type of BsonDocument. /// </summary> /// <param name="defaultDocumentType">The default document type.</param> /// <param name="collectionName">The name of the collection.</param> /// <returns>An instance of MongoCollection.</returns> public virtual MongoCollection GetCollection(Type defaultDocumentType, string collectionName) { var collectionSettings = new MongoCollectionSettings(); return(GetCollection(defaultDocumentType, collectionName, collectionSettings)); }
/// <summary> /// Gets a MongoCollection instance representing a collection on this database /// with a default document type of BsonDocument. /// </summary> /// <param name="defaultDocumentType">The default document type.</param> /// <param name="collectionName">The name of the collection.</param> /// <param name="collectionSettings">The settings to use when accessing this collection.</param> /// <returns>An instance of MongoCollection.</returns> public virtual MongoCollection GetCollection(Type defaultDocumentType, string collectionName, MongoCollectionSettings collectionSettings) { var collectionDefinition = typeof(MongoCollection <>); var collectionType = collectionDefinition.MakeGenericType(defaultDocumentType); var constructorInfo = collectionType.GetConstructor(new Type[] { typeof(MongoDatabase), typeof(string), typeof(MongoCollectionSettings) }); return((MongoCollection)constructorInfo.Invoke(new object[] { this, collectionName, collectionSettings })); }
public virtual MongoCollection GetCollection(MongoCollectionSettings collectionSettings) { return(GetCollection(collectionSettings.DefaultDocumentType, collectionSettings.CollectionName, collectionSettings)); }
/// <summary> /// Gets a MongoCollection instance representing a collection on this database /// with a default document type of TDefaultDocument. /// </summary> /// <param name="collectionName">The name of the collection.</param> /// <param name="collectionSettings">The settings to use when accessing this collection.</param> /// <returns>An instance of MongoCollection.</returns> public virtual MongoCollection <BsonDocument> GetCollection(string collectionName, MongoCollectionSettings collectionSettings) { return(GetCollection <BsonDocument>(collectionName, collectionSettings)); }
/// <summary> /// Gets a MongoCollection instance representing a collection on this database /// with a default document type of TDefaultDocument. /// </summary> /// <typeparam name="TDefaultDocument">The default document type for this collection.</typeparam> /// <param name="collectionName">The name of the collection.</param> /// <param name="collectionSettings">The settings to use when accessing this collection.</param> /// <returns>An instance of MongoCollection.</returns> public virtual MongoCollection <TDefaultDocument> GetCollection <TDefaultDocument>( string collectionName, MongoCollectionSettings collectionSettings) { return(new MongoCollection <TDefaultDocument>(this, collectionName, collectionSettings)); }
// constructors public MongoCollectionImpl(IMongoDatabase database, CollectionNamespace collectionNamespace, MongoCollectionSettings settings, ICluster cluster, IOperationExecutor operationExecutor) : this(database, collectionNamespace, settings, cluster, operationExecutor, Ensure.IsNotNull(settings, "settings").SerializerRegistry.GetSerializer <TDocument>()) { }
// public methods /// <summary> /// Creates a clone of the settings. /// </summary> /// <returns>A clone of the settings.</returns> public virtual MongoCollectionSettings Clone() { var clone = new MongoCollectionSettings(); clone._assignIdOnInsert = _assignIdOnInsert.Clone(); clone._guidRepresentation = _guidRepresentation.Clone(); clone._readEncoding = _readEncoding.Clone(); clone._readPreference = _readPreference.Clone(); clone._writeConcern = _writeConcern.Clone(); clone._writeEncoding = _writeEncoding.Clone(); return clone; }
/// <summary> /// Gets a MongoCollection instance representing a collection on this database /// with a default document type of BsonDocument. /// </summary> /// <param name="collectionName">The name of the collection.</param> /// <returns>An instance of MongoCollection.</returns> public virtual MongoCollection <BsonDocument> GetCollection(string collectionName) { var collectionSettings = new MongoCollectionSettings <BsonDocument>(this, collectionName); return(GetCollection(collectionSettings)); }
/// <summary> /// Gets a MongoCollection instance representing a collection on this database /// with a default document type of BsonDocument. /// </summary> /// <param name="defaultDocumentType">The default document type.</param> /// <param name="collectionName">The name of the collection.</param> /// <param name="collectionSettings">The settings to use when accessing this collection.</param> /// <returns>An instance of MongoCollection.</returns> public virtual MongoCollection GetCollection(Type defaultDocumentType, string collectionName, MongoCollectionSettings collectionSettings) { var collectionDefinition = typeof(MongoCollection <>); var collectionType = collectionDefinition.MakeGenericType(defaultDocumentType); var constructorParameterTypes = new Type[] { typeof(MongoDatabase), typeof(string), typeof(MongoCollectionSettings), typeof(IOperationExecutor) }; var constructorInfo = collectionType.GetTypeInfo() .GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance) .Where(c => c.GetParameters().Select(p => p.ParameterType).SequenceEqual(constructorParameterTypes)) .Single(); return((MongoCollection)constructorInfo.Invoke(new object[] { this, collectionName, collectionSettings, _operationExecutor })); }
public void TestStrictWrite() { var settings = new MongoCollectionSettings { WriteEncoding = new UTF8Encoding(false, true) }; var collection = _database.GetCollection(Configuration.TestCollection.Name, settings); var document = new BsonDocument("x", "\udc00"); // invalid lone low surrogate Assert.Throws<EncoderFallbackException>(() => { collection.Insert(document); }); }
public virtual MongoCollection <TDefaultDocument> GetCollection <TDefaultDocument>( MongoCollectionSettings <TDefaultDocument> collectionSettings) { return(GetCollection <TDefaultDocument>(collectionSettings.CollectionName, collectionSettings)); }
public void TestSaveD() { var collectionSettings = new MongoCollectionSettings<D>(_database, "test") { GuidRepresentation = GuidRepresentation.Standard }; var collection = _database.GetCollection(collectionSettings); collection.Drop(); var id = new Guid("00112233-4455-6677-8899-aabbccddeeff"); var doc = new D { Id = id, X = 1 }; collection.Insert(doc); Assert.AreEqual(1, collection.Count()); var fetched = collection.FindOne(); Assert.AreEqual(id, fetched.Id); Assert.AreEqual(1, fetched.X); doc.X = 2; collection.Save(doc); Assert.AreEqual(1, collection.Count()); fetched = collection.FindOne(); Assert.AreEqual(id, fetched.Id); Assert.AreEqual(2, fetched.X); }
/// <summary> /// Gets a MongoCollection instance representing a collection on this database /// with a default document type of TDefaultDocument. /// </summary> /// <typeparam name="TDefaultDocument">The default document type for this collection.</typeparam> /// <param name="collectionName">The name of the collection.</param> /// <returns>An instance of MongoCollection.</returns> public virtual MongoCollection <TDefaultDocument> GetCollection <TDefaultDocument>(string collectionName) { var collectionSettings = new MongoCollectionSettings(); return(GetCollection <TDefaultDocument>(collectionName, collectionSettings)); }