C# Driver.MongoInsertOptions类代码示例

        public void TestInsertUpdateAndSaveWithElementNameStartingWithDollarSign()
        {
            var server = Configuration.TestServer;
            var database = Configuration.TestDatabase;
            var collection = Configuration.TestCollection;
            collection.Drop();

            var document = new BsonDocument
            {
                { "_id", 1 },
                { "v", new BsonDocument("$x", 1) } // server doesn't allow "$" at top level
            };
            var insertOptions = new MongoInsertOptions { CheckElementNames = false };
            collection.Insert(document, insertOptions);
            document = collection.FindOne();
            Assert.AreEqual(1, document["v"]["$x"].AsInt32);

            document["v"]["$x"] = 2;
            var query = Query.EQ("_id", 1);
            var update = Update.Replace(document);
            var updateOptions = new MongoUpdateOptions { CheckElementNames = false };
            collection.Update(query, update, updateOptions);
            document = collection.FindOne();
            Assert.AreEqual(2, document["v"]["$x"].AsInt32);

            document["v"]["$x"] = 3;
            collection.Save(document, insertOptions);
            document = collection.FindOne();
            Assert.AreEqual(3, document["v"]["$x"].AsInt32);
        }

        public void TestInsertUpdateAndSaveWithElementNameStartingWithDollarSign()
        {
            // starting with version 2.5.2 the server got stricter about dollars in element names
            // so this test should only be run when testing against older servers
            var server = Configuration.TestServer;
            if (server.BuildInfo.Version < new Version(2, 6, 0))
            {
                var database = Configuration.TestDatabase;
                var collection = Configuration.TestCollection;
                collection.Drop();

                var document = new BsonDocument
                {
                    { "_id", 1 },
                    { "v", new BsonDocument("$x", 1) } // server doesn't allow "$" at top level
                };
                var insertOptions = new MongoInsertOptions { CheckElementNames = false };
                collection.Insert(document, insertOptions);
                document = collection.FindOne();
                Assert.AreEqual(1, document["v"]["$x"].AsInt32);

                document["v"]["$x"] = 2;
                var query = Query.EQ("_id", 1);
                var update = Update.Replace(document);
                var updateOptions = new MongoUpdateOptions { CheckElementNames = false };
                collection.Update(query, update, updateOptions);
                document = collection.FindOne();
                Assert.AreEqual(2, document["v"]["$x"].AsInt32);

                document["v"]["$x"] = 3;
                collection.Save(document, insertOptions);
                document = collection.FindOne();
                Assert.AreEqual(3, document["v"]["$x"].AsInt32);
            }
        }

        public void TestInsertUpdateAndSaveWithElementNameStartingWithDollarSign()
        {
            var server = MongoServer.Create("mongodb://localhost/?safe=true;slaveOk=true");
            var database = server["onlinetests"];
            var collection = database["test"];
            collection.Drop();

            var document = new BsonDocument
            {
                { "_id", 1 },
                { "v", new BsonDocument("$x", 1) } // server doesn't allow "$" at top level
            };
            var insertOptions = new MongoInsertOptions { CheckElementNames = false };
            collection.Insert(document, insertOptions);
            document = collection.FindOne();
            Assert.AreEqual(1, document["v"].AsBsonDocument["$x"].AsInt32);

            document["v"].AsBsonDocument["$x"] = 2;
            var query = Query.EQ("_id", 1);
            var update = Update.Replace(document);
            var updateOptions = new MongoUpdateOptions { CheckElementNames = false };
            collection.Update(query, update, updateOptions);
            document = collection.FindOne();
            Assert.AreEqual(2, document["v"].AsBsonDocument["$x"].AsInt32);

            document["v"].AsBsonDocument["$x"] = 3;
            collection.Save(document, insertOptions);
            document = collection.FindOne();
            Assert.AreEqual(3, document["v"].AsBsonDocument["$x"].AsInt32);
        }

        public void TestInsertBatchMultipleBatchesWriteConcernEnabledContinueOnErrorTrue()
        {
            var collectionName = Configuration.TestCollection.Name;
            var collectionSettings = new MongoCollectionSettings { WriteConcern = WriteConcern.Acknowledged };
            var collection = Configuration.TestDatabase.GetCollection<BsonDocument>(collectionName, collectionSettings);
            if (collection.Exists()) { collection.Drop(); }

            using (Configuration.TestDatabase.RequestStart())
            {
                var maxMessageLength = Configuration.TestServer.RequestConnection.ServerInstance.MaxMessageLength;

                var filler = new string('x', maxMessageLength / 3); // after overhead results in two documents per sub-batch
                var documents = new BsonDocument[]
                {
                    // first sub-batch
                    new BsonDocument { { "_id", 1 }, { "filler", filler } },
                    new BsonDocument { { "_id", 2 }, { "filler", filler } },
                    // second sub-batch
                    new BsonDocument { { "_id", 3 }, { "filler", filler } },
                    new BsonDocument { { "_id", 3 }, { "filler", filler } }, // duplicate _id error
                    // third sub-batch
                    new BsonDocument { { "_id", 4 }, { "filler", filler } },
                    new BsonDocument { { "_id", 5 }, { "filler", filler } },
                };

                try
                {
                    var options = new MongoInsertOptions { Flags = InsertFlags.ContinueOnError };
                    collection.InsertBatch(documents, options);
                }
                catch (WriteConcernException ex)
                {
                    var results = (IEnumerable<WriteConcernResult>)ex.Data["results"];
                    Assert.AreEqual(3, results.Count());

                    var result1 = results.ElementAt(0);
                    Assert.AreEqual(false, result1.HasLastErrorMessage);

                    var result2 = results.ElementAt(1);
                    Assert.AreEqual(true, result2.HasLastErrorMessage);

                    var result3 = results.ElementAt(2);
                    Assert.AreEqual(false, result3.HasLastErrorMessage);
                }

                Assert.AreEqual(1, collection.Count(Query.EQ("_id", 1)));
                Assert.AreEqual(1, collection.Count(Query.EQ("_id", 2)));
                Assert.AreEqual(1, collection.Count(Query.EQ("_id", 3)));
                Assert.AreEqual(1, collection.Count(Query.EQ("_id", 4)));
                Assert.AreEqual(1, collection.Count(Query.EQ("_id", 5)));
            }
        }

        public void TestInsertBatchMultipleBatchesWriteConcernDisabledContinueOnErrorTrue()
        {
            var collectionName = Configuration.TestCollection.Name;
            var collectionSettings = new MongoCollectionSettings { WriteConcern = WriteConcern.Unacknowledged };
            var collection = Configuration.TestDatabase.GetCollection<BsonDocument>(collectionName, collectionSettings);
            if (collection.Exists()) { collection.Drop(); }

            using (Configuration.TestDatabase.RequestStart())
            {
                var maxMessageLength = Configuration.TestServer.RequestConnection.ServerInstance.MaxMessageLength;

                var filler = new string('x', maxMessageLength / 3); // after overhead results in two documents per sub-batch
                var documents = new BsonDocument[]
                {
                    // first sub-batch
                    new BsonDocument { { "_id", 1 }, { "filler", filler } },
                    new BsonDocument { { "_id", 2 }, { "filler", filler } },
                    // second sub-batch
                    new BsonDocument { { "_id", 3 }, { "filler", filler } },
                    new BsonDocument { { "_id", 3 }, { "filler", filler } }, // duplicate _id error
                    // third sub-batch
                    new BsonDocument { { "_id", 4 }, { "filler", filler } },
                    new BsonDocument { { "_id", 5 }, { "filler", filler } },
                };

                var options = new MongoInsertOptions { Flags = InsertFlags.ContinueOnError };
                var result = collection.InsertBatch(documents, options);

                Assert.AreEqual(null, result);
                Assert.AreEqual(1, collection.Count(Query.EQ("_id", 1)));
                Assert.AreEqual(1, collection.Count(Query.EQ("_id", 2)));
                Assert.AreEqual(1, collection.Count(Query.EQ("_id", 3)));
                Assert.AreEqual(1, collection.Count(Query.EQ("_id", 4)));
                Assert.AreEqual(1, collection.Count(Query.EQ("_id", 5)));
            }
        }

        public void TestInsertBatchMultipleBatchesWriteConcernEnabledContinueOnErrorTrue()
        {
            var collectionName = Configuration.TestCollection.Name;
            var collectionSettings = new MongoCollectionSettings { WriteConcern = WriteConcern.Acknowledged };
            var collection = Configuration.TestDatabase.GetCollection<BsonDocument>(collectionName, collectionSettings);
            if (collection.Exists()) { collection.Drop(); }

            using (Configuration.TestDatabase.RequestStart())
            {
                var maxMessageLength = Configuration.TestServer.RequestConnection.ServerInstance.MaxMessageLength;

                var filler = new string('x', maxMessageLength / 3); // after overhead results in two documents per sub-batch
                var documents = new BsonDocument[]
                {
                    // first sub-batch
                    new BsonDocument { { "_id", 1 }, { "filler", filler } },
                    new BsonDocument { { "_id", 2 }, { "filler", filler } },
                    // second sub-batch
                    new BsonDocument { { "_id", 3 }, { "filler", filler } },
                    new BsonDocument { { "_id", 3 }, { "filler", filler } }, // duplicate _id error
                    // third sub-batch
                    new BsonDocument { { "_id", 4 }, { "filler", filler } },
                    new BsonDocument { { "_id", 5 }, { "filler", filler } },
                };

                var options = new MongoInsertOptions { Flags = InsertFlags.ContinueOnError };
                var exception = Assert.Throws<MongoDuplicateKeyException>(() => { collection.InsertBatch(documents, options); });
                var result = exception.WriteConcernResult;

                var expectedResult = new ExpectedWriteConcernResult()
                {
                    HasLastErrorMessage = true
                };
                CheckExpectedResult(expectedResult, result);

                var results = ((IEnumerable<WriteConcernResult>)exception.Data["results"]).ToArray();
                if (results.Length == 3)
                {
                    Assert.AreEqual(false, results[0].HasLastErrorMessage);
                    Assert.AreEqual(true, results[1].HasLastErrorMessage);
                    Assert.AreEqual(false, results[2].HasLastErrorMessage);
                }
                else
                {
                    // it the opcode was emulated there will just be one synthesized result
                    Assert.AreEqual(1, results.Length);
                    Assert.AreEqual(true, results[0].HasLastErrorMessage);
                }

                Assert.AreEqual(1, collection.Count(Query.EQ("_id", 1)));
                Assert.AreEqual(1, collection.Count(Query.EQ("_id", 2)));
                Assert.AreEqual(1, collection.Count(Query.EQ("_id", 3)));
                Assert.AreEqual(1, collection.Count(Query.EQ("_id", 4)));
                Assert.AreEqual(1, collection.Count(Query.EQ("_id", 5)));
            }
        }

        public void TestInsertBatchContinueOnError()
        {
            var collection = Configuration.TestCollection;
            collection.Drop();
            collection.CreateIndex(IndexKeys.Ascending("x"), IndexOptions.SetUnique(true));

            var batch = new BsonDocument[]
            {
                new BsonDocument("x", 1),
                new BsonDocument("x", 1), // duplicate
                new BsonDocument("x", 2),
                new BsonDocument("x", 2), // duplicate
                new BsonDocument("x", 3),
                new BsonDocument("x", 3) // duplicate
            };

            // try the batch without ContinueOnError
            var exception = Assert.Throws<MongoDuplicateKeyException>(() => collection.InsertBatch(batch));
            var result = exception.WriteConcernResult;

            var expectedResult = new ExpectedWriteConcernResult
            {
                HasLastErrorMessage = true
            };
            CheckExpectedResult(expectedResult, result);

            Assert.AreEqual(1, collection.Count());
            Assert.AreEqual(1, collection.FindOne()["x"].AsInt32);

            // try the batch again with ContinueOnError
            if (_server.BuildInfo.Version >= new Version(2, 0, 0))
            {
                var options = new MongoInsertOptions { Flags = InsertFlags.ContinueOnError };
                exception = Assert.Throws<MongoDuplicateKeyException>(() => collection.InsertBatch(batch, options));
                result = exception.WriteConcernResult;

                expectedResult = new ExpectedWriteConcernResult
                {
                    HasLastErrorMessage = true
                };
                CheckExpectedResult(expectedResult, result);

                Assert.AreEqual(3, collection.Count());
            }
        }

 public void TestCountWithReadPreferenceFromFind()
 {
     _collection.Drop();
     var all = LegacyTestConfiguration.Server.Secondaries.Length + 1;
     var options = new MongoInsertOptions { WriteConcern = new WriteConcern(w: all) };
     _collection.Insert(new BsonDocument("x", 1), options);
     _collection.Insert(new BsonDocument("x", 2), options);
     var count = _collection.Find(Query.EQ("x", 1)).SetReadPreference(ReadPreference.Secondary).Count();
     Assert.AreEqual(1, count);
 }

        private void Initialize()
        {
            lock (Sync)
            {
                var database = MongoDatabase.Create(_connectionString);
                if (!database.CollectionExists(_collectionName))
                {
                    var options = CollectionOptions
                        .SetCapped(true)
                        .SetAutoIndexId(true)
                        .SetMaxSize(_maxSize);

                    if (_maxDocuments != int.MaxValue)
                        options.SetMaxDocuments(_maxDocuments);

                    database.CreateCollection(_collectionName, options);
                }

                _collection = database.GetCollection(_collectionName);
                _mongoInsertOptions = new MongoInsertOptions { CheckElementNames = false };
            }
        }

 private void addNewUser()
 {
     var options = new MongoInsertOptions(names) { SafeMode = SafeMode.True };
     BsonDocument name = new BsonDocument {
         { "name", newName }
         };
     names.Save(name, options);
 }

        public void TestInsertBatchContinueOnError() {
            var collection = database["continueonerror"];
            collection.Drop();
            collection.CreateIndex(IndexKeys.Ascending("x"), IndexOptions.SetUnique(true));

            var batch = new BsonDocument[] {
                new BsonDocument("x", 1),
                new BsonDocument("x", 1), // duplicate
                new BsonDocument("x", 2),
                new BsonDocument("x", 2), // duplicate
                new BsonDocument("x", 3),
                new BsonDocument("x", 3) // duplicate
            };

            // try the batch without ContinueOnError
            try {
                collection.InsertBatch(batch);
            } catch (MongoSafeModeException) {
                Assert.AreEqual(1, collection.Count());
                Assert.AreEqual(1, collection.FindOne()["x"].AsInt32);
            }

            // try the batch again with ContinueOnError
            try {
                var options = new MongoInsertOptions(collection) { Flags = InsertFlags.ContinueOnError };
                collection.InsertBatch(batch, options);
            } catch (MongoSafeModeException) {
                Assert.AreEqual(3, collection.Count());
            }
        }

 public void Save(IEnumerable<Object> docs)
 {
     var mongoInsertOptions = new MongoInsertOptions();
     mongoInsertOptions.WriteConcern = WriteConcern.Acknowledged;
     _collection.InsertBatch(docs, mongoInsertOptions);
 }

        // 将积累的内存对象保存到数据库中
        public int Flush(out string strError)
        {
            strError = "";

            if (this.SearchLogCollection == null)
            {
                this._searchLogCache.Clear();
                return 0;
            }

            try
            {
                List<SearchLogItem> whole = new List<SearchLogItem>();

                // 将打算写入数据库的内存对象移出容器，这样可以减少锁定时间
                if (this.m_lock.TryEnterWriteLock(m_nLockTimeout) == false)
                    throw new ApplicationException("锁定尝试中超时");
                try
                {
                    if (this._searchLogCache.Count == 0)
                        return 0;

                    whole.AddRange(this._searchLogCache);
                    this._searchLogCache.Clear();
                    // this.RemoveRange(0, nCount);
                }
                finally
                {
                    this.m_lock.ExitWriteLock();
                }

                if (this.m_lock.TryEnterReadLock(m_nLockTimeout) == false)
                    throw new ApplicationException("锁定尝试中超时");
                try
                {
                    MongoCollection<SearchLogItem> db_items = this.SearchLogCollection;
                    MongoInsertOptions options = new MongoInsertOptions() { WriteConcern = WriteConcern.Unacknowledged };
                    foreach (SearchLogItem item in whole)
                    {
                        db_items.Insert(item, options);
                    }
                }
                finally
                {
                    this.m_lock.ExitReadLock();
                }

                // TODO: 是否考虑失败后把元素重新插入回this数组?

                return 1;
            }
            catch (Exception ex)
            {
                strError = "检索日志写入数据库的过程发生错误: " + ex.Message;
                return -1;
            }
        }

        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);
        }

        private void Initialize()
        {
            lock (Sync)
            {
                var mongoUrl = MongoUrl.Create(_connectionString);
                var mongoClient = new MongoClient(mongoUrl);
                var server = mongoClient.GetServer();
                var database = server.GetDatabase(mongoUrl.DatabaseName);
                if (!database.CollectionExists(_collectionName))
                {
                    var options = CollectionOptions
                        .SetCapped(true)
                        .SetAutoIndexId(true)
                        .SetMaxSize(_maxSize);

                    if (_maxDocuments != int.MaxValue)
                        options.SetMaxDocuments(_maxDocuments);

                    database.CreateCollection(_collectionName, options);
                }

                _collection = database.GetCollection(_collectionName);
                _mongoInsertOptions = new MongoInsertOptions { Flags = InsertFlags.ContinueOnError };
            }
        }