C# MongoCollection.EnsureIndex方法代码示例

        public CommandEnvelopeRouteOnRequestCostcentreRepository(string connectionString)
            : base(connectionString)
        {
            _commandEnvelopeRouteOnRequestCostcentreCollection = CurrentMongoDB.GetCollection<CommandEnvelopeRouteOnRequestCostcentre>(_commandEnvelopeRouteOnRequestCostcentreCollectionName);
            _commandEnvelopeRouteOnRequestCostcentreCollection.EnsureIndex(IndexKeys<CommandEnvelopeRouteOnRequestCostcentre>.Ascending(n => n.Id), IndexOptions.SetUnique(true));
            _commandEnvelopeRouteOnRequestCostcentreCollection.EnsureIndex(IndexKeys<CommandEnvelopeRouteOnRequestCostcentre>.Ascending(n => n.EnvelopeId));
            _commandEnvelopeRouteOnRequestCostcentreCollection.EnsureIndex(IndexKeys<CommandEnvelopeRouteOnRequestCostcentre>.Ascending(n => n.CostCentreId));
            _commandEnvelopeRouteOnRequestCostcentreCollection.EnsureIndex(IndexKeys<CommandEnvelopeRouteOnRequestCostcentre>.Ascending(n => n.EnvelopeRoutePriority));
            _commandEnvelopeRouteOnRequestCostcentreCollection.EnsureIndex(IndexKeys<CommandEnvelopeRouteOnRequestCostcentre>.Ascending(n => n.EnvelopeArrivalAtServerTick));
            _commandEnvelopeRouteOnRequestCostcentreCollection.EnsureIndex(IndexKeys<CommandEnvelopeRouteOnRequestCostcentre>.Ascending(n => n.DocumentType));

            _commandEnvelopeRoutingStatusCollection = CurrentMongoDB.GetCollection<CommandEnvelopeRoutingStatus>(_commandEnvelopeRoutingStatusCollectionName);
            _commandEnvelopeRoutingStatusCollection.EnsureIndex(IndexKeys<CommandEnvelopeRoutingStatus>.Ascending(n => n.Id), IndexOptions.SetUnique(true));
            _commandEnvelopeRoutingStatusCollection.EnsureIndex(IndexKeys<CommandEnvelopeRoutingStatus>.Ascending(n => n.DestinationCostCentreApplicationId));
            _commandEnvelopeRoutingStatusCollection.EnsureIndex(IndexKeys<CommandEnvelopeRoutingStatus>.Ascending(n => n.EnvelopeDeliveredAtServerTick));

            _commandEnvelopeProcessingAuditCollection = CurrentMongoDB.GetCollection<CommandEnvelopeProcessingAudit>(_commandEnvelopeProcessingAuditCollectionName);
            _commandEnvelopeProcessingAuditCollection.EnsureIndex(IndexKeys<CommandEnvelopeProcessingAudit>.Ascending(n => n.Id), IndexOptions.SetUnique(true));
            _commandEnvelopeProcessingAuditCollection.EnsureIndex(IndexKeys<CommandEnvelopeProcessingAudit>.Ascending(n => n.GeneratedByCostCentreApplicationId));
            _commandEnvelopeProcessingAuditCollection.EnsureIndex(IndexKeys<CommandEnvelopeProcessingAudit>.Ascending(n => n.RecipientCostCentreId));
            _commandEnvelopeProcessingAuditCollection.EnsureIndex(IndexKeys<CommandEnvelopeProcessingAudit>.Ascending(n => n.DocumentId));
            _commandEnvelopeProcessingAuditCollection.EnsureIndex(IndexKeys<CommandEnvelopeProcessingAudit>.Ascending(n => n.Status));
            _commandEnvelopeProcessingAuditCollection.EnsureIndex(IndexKeys<CommandProcessingAudit>.Ascending(n => n.ParentDocumentId));
            _commandEnvelopeProcessingAuditCollection.EnsureIndex(IndexKeys<CommandProcessingAudit>.Ascending(n => n.DateInserted));

            _CommandEnvelopeRoutingTrackerCollection = CurrentMongoDB.GetCollection<CommandEnvelopeRoutingTracker>(_commandEnvelopeRoutingTrackerCollectionName);

            _CommandEnvelopeRoutingTrackerCollection.CreateIndex(IndexKeys<CommandEnvelopeRoutingTracker>.Ascending(n => n.Id), IndexOptions.SetUnique(true));
            _CommandEnvelopeRoutingTrackerCollection.CreateIndex(IndexKeys<CommandEnvelopeRoutingTracker>.Ascending(n => n.EnvelopeArrivalAtServerTick));
            _CommandEnvelopeRoutingTrackerCollection.CreateIndex(IndexKeys<CommandEnvelopeRoutingTracker>.Ascending(n => n.EnvelopeId));
        }

        public MongoDbBlackBox(string connectionstring, string eventstorename)
        {
            var mdbClient = new MongoClient(connectionstring);
            var mdbServer = mdbClient.GetServer();
            var mdb = mdbServer.GetDatabase(eventstorename);

            _eventCol = mdb.GetCollection("Events");
            _eventCol.EnsureIndex(new IndexKeysBuilder().Ascending("sequencenumber"));
            _eventCol.EnsureIndex(new IndexKeysBuilder().Ascending("name"));
            _eventCol.EnsureIndex(new IndexKeysBuilder().Ascending("context"));
        }

        public MongoDataProvider(string connectionString)
            : base(connectionString)
        {
            var databaseName = MongoUrl.Create(connectionString).DatabaseName;
            var server = MongoServer.Create(connectionString);
            var database = server.GetDatabase(databaseName);

            _items = database.GetCollection<ItemDto>("items");
            _items.EnsureIndex(IndexKeys.Ascending(new[] {"ParentId"}));
            _items.EnsureIndex(IndexKeys.Ascending(new[] {"TemplateId"}));
        }

        public CommandRoutingOnRequestMongoRepository(string connectionStringM1)
            : base(connectionStringM1)
        {
            _CommandRouteOnRequestCollection = CurrentMongoDB.GetCollection<CommandRouteOnRequest>(_commandRouteOnRequestCollectionName);
            _CommandRouteOnRequestCostcentreCollection = CurrentMongoDB.GetCollection<CommandRouteOnRequestCostcentre>(_commandRouteOnRequestCostcentreCollectionName);
            _commandRoutingStatusCollection = CurrentMongoDB.GetCollection<CommandRoutingStatus>(_commandCommandRoutingStatusCollectionName);
            _counterHelper = new IdCounterHelper(connectionStringM1);

            _CommandRouteOnRequestCollection.EnsureIndex(IndexKeys<CommandRouteOnRequest>.Ascending(n => n.CommandId), IndexOptions.SetUnique(true));
            _CommandRouteOnRequestCollection.EnsureIndex(IndexKeys<CommandRouteOnRequest>.Ascending(n => n.DocumentId));
            _CommandRouteOnRequestCostcentreCollection.EnsureIndex(IndexKeys<CommandRouteOnRequestCostcentre>.Ascending(n => n.CommandRouteOnRequestId).Ascending(n => n.CostCentreId), IndexOptions.SetUnique(true));
            _commandRoutingStatusCollection.EnsureIndex(IndexKeys<CommandRoutingStatus>.Ascending(n => n.CommandRouteOnRequestId).Ascending(n => n.DestinationCostCentreApplicationId), IndexOptions.SetUnique(true));
            _commandRoutingStatusCollection.EnsureIndex(IndexKeys<CommandRoutingStatus>.Ascending(n => n.CommandId).Ascending(n => n.DestinationCostCentreApplicationId), IndexOptions.SetUnique(true));
        }

        public void Setup()
        {
            _server = Configuration.TestServer;
            _database = Configuration.TestDatabase;
            _collection = Configuration.GetTestCollection<B>();

            _collection.Drop();
            _collection.EnsureIndex(new IndexKeysBuilder().Ascending("a", "b"), IndexOptions.SetName("i"));
            _collection.EnsureIndex(new IndexKeysBuilder().Ascending("a", "b"), IndexOptions.SetName("i"));

            _collection.Insert(new B { Id = ObjectId.GenerateNewId(), a = 1, b = 10, c = 100 });
            _collection.Insert(new B { Id = ObjectId.GenerateNewId(), a = 2, b = 20, c = 200 });
            _collection.Insert(new B { Id = ObjectId.GenerateNewId(), a = 3, b = 30, c = 300 });
            _collection.Insert(new B { Id = ObjectId.GenerateNewId(), a = 4, b = 40, c = 400 });
        }

 public void TestSetUp()
 {
     if (_testDb.CollectionExists(TestCollectionName))
         _testDb.DropCollection(TestCollectionName);
     _collection = _testDb.GetCollection<BsonDocument>(TestCollectionName);
     _collection.EnsureIndex(IndexKeys.Ascending("key"), IndexOptions.SetUnique(true));
 }

        public void Create(MongoCollection collection,bool isBackground)
        {
            var index  = OnBuildIndex();
          
            log.Debug("Index {0}: {1}",name,index);
            log.Info("Ensuring index {0} exists on collection {1}",name,collection.Name);

            collection.EnsureIndex(index, new IndexOptionsBuilder().SetBackground(isBackground).SetName(name));
        }

        public DrugLord()
        {
            database = MongoDatabase.Create(ConfigurationManager.AppSettings["mongo"]);

            money = database.GetCollection("money");
            money.EnsureIndex(IndexKeys.Ascending("userToken", "secretCode"), IndexOptions.SetUnique(true));

            drugs = database.GetCollection("drugs");
            drugs.EnsureIndex(IndexKeys.Ascending("userToken", "secretCode"), IndexOptions.SetUnique(true));
        }

        public PatientRepository()
        {
            _server = new MongoServer(new MongoServerSettings { Server = new MongoServerAddress(_DBHOST), SafeMode = SafeMode.True });

            //patients
            _patients = _server.GetDatabase(_DBNAME).GetCollection<PatientModel>("patients");
            _patients.EnsureIndex(IndexKeys.Ascending("_id"), IndexOptions.SetUnique(true));
            _gridFS = _server.GetDatabase(_DBNAME).GridFS;

            new MongoDB.Web.Providers.MongoDBMembershipProvider();
        }

        public void SetUp()
        {
            var db = Configuration.TestDatabase;
            _collection = db.GetCollection<GeoClass>("geo");

            _collection.Drop();
            _collection.EnsureIndex(IndexKeys<GeoClass>.GeoSpatialSpherical(x => x.Location));
            _collection.EnsureIndex(IndexKeys<GeoClass>.GeoSpatialSpherical(x => x.Surrounding));

            var doc = new GeoClass
            {
                Id = 1,
                Location = GeoJson.Point(GeoJson.Geographic(40.5, 18.5)),
                Surrounding = GeoJson.Polygon(
                    GeoJson.Geographic(40, 18),
                    GeoJson.Geographic(40, 19),
                    GeoJson.Geographic(41, 19),
                    GeoJson.Geographic(40, 18))
            };

            _collection.Save(doc);
        }

 public CommandProcessingAuditRepository(string connectionString) : base(connectionString)
 {
   _commandProcessingAuditCollection = CurrentMongoDB.GetCollection<CommandProcessingAudit>(_commandProcessingAuditCollectionName);
   _commandProcessingAuditCollection.EnsureIndex(IndexKeys<CommandProcessingAudit>.Ascending(n => n.Id), IndexOptions.SetUnique(true));
   _commandProcessingAuditCollection.EnsureIndex(IndexKeys<CommandProcessingAudit>.Ascending(n => n.CostCentreApplicationId));
   _commandProcessingAuditCollection.EnsureIndex(IndexKeys<CommandProcessingAudit>.Ascending(n => n.Status));
   _commandProcessingAuditCollection.EnsureIndex(IndexKeys<CommandProcessingAudit>.Ascending(n => n.DocumentId));
   _commandProcessingAuditCollection.EnsureIndex(IndexKeys<CommandProcessingAudit>.Ascending(n => n.ParentDocumentId));
   _commandProcessingAuditCollection.EnsureIndex(IndexKeys<CommandProcessingAudit>.Ascending(n => n.DateInserted));
 }

 public Boolean GuardarProveedor(Proveedor P)
 {
     try
     {
         coleccion = bd.GetCollection<Proveedor>("Proveedor");
         coleccion.EnsureIndex(new IndexKeysBuilder().
             Ascending("Rut"), IndexOptions.SetUnique(true));
         this.mensaje.Append(coleccion.Insert(P).Response.ToString());
         return true;
     }
     catch (MongoSafeModeException MSME)
     {
         this.mensaje.Append("Rut Duplicado: " + P.Rut);
     }
     catch (Exception E)
     {
         this.mensaje.Append(E.Message);
     }
     return false;
 }

        public MessageSessionInfo EnsureSession(string appName, string sessionId, ObjectId from, ObjectId to, MongoCollection<MessageSessionInfo> collection)
        {
            var session = collection.Find(Query.EQ("session_id", sessionId)).SetFields("session_id", "user_1", "user_2", "user1_is_deleted", "user2_is_deleted").FirstOrDefault();

            if (session == null)
            {
                session = new MessageSessionInfo()
                {
                    SessionId = sessionId,
                    User1 = from,
                    User2 = to,
                    Messages = new MessageInfo[0],
                    LastUpdated = DateTime.Now,
                    UnreadMessagesUser1 = 0,
                    UnreadMessagesUser2 = 0
                };
                collection.EnsureIndex("session_id");
                collection.Insert(session);
            }
            return session;
        }

        /// <summary>
        /// Calculate the amount of documents
        /// </summary>
        /// <param name="name">Field name to group by</param>
        /// <returns>Document list represented by "Key" and "Value" inside aggregate result object</returns>
        public AggregateResult GroupByCount(string name, MongoCollection collection, BsonDocument sort, BsonDocument limit, BsonDocument skip, BsonDocument match, bool countGroups =false)
        {
            // prepare pipeline operations
            var group = new BsonDocument
            {
                {
                    "$group",
                    new BsonDocument
                    {
                        {
                            "_id", new BsonDocument
                            {
                                {
                                    "Key","$" + name
                                }
                            }
                        },
                        {
                            "Value", new BsonDocument
                            {
                                {
                                    "$sum", 1
                                }
                            }
                        }
                    }
                }
            };

            var project = new BsonDocument
            {
                {
                    "$project",
                    new BsonDocument
                    {
                        {"_id", 0}, // remove reference to _id
                        {"Key","$_id.Key"}, // set reference to "_id.Name" as "UserName"
                        {"Value", 1}, // dont  change "Count"
                    }
                }
            };

            List<BsonDocument> pipeline = new List<BsonDocument>{ };
            if (match != null)
                pipeline.Add(match);

            pipeline.Add(group);
            if (countGroups)
            {
                var total = new BsonDocument
                {
                    {
                        "$group",
                        new BsonDocument
                        {
                            {
                                "_id", 0
                            },
                            {
                                "Total", new BsonDocument
                                {
                                    {
                                        "$sum", 1
                                    }
                                }
                            }
                        }
                    }
                };

                pipeline.Add(total);
            }
            else
            {
                pipeline.Add(project);

                if (sort != null)
                {
                    pipeline.Add(sort);
                }
                pipeline.Add(skip);
                pipeline.Add(limit);
            }
            collection.EnsureIndex(IndexKeys.Ascending(name));
            return collection.Aggregate(pipeline);
        }

        static StudentManager()
        {
            collection = new MongoClient("mongodb://localhost").GetServer().GetDatabase("EAMSystem").GetCollection<Student>("Students");

            collection.EnsureIndex("StuNo");
        }