MongoClient clients = new MongoClient(_ibcoptions.Value.MongoConnStr);//配置文件读取
            //获取指定数据库
            IMongoDatabase dbs = clients.GetDatabase(_ibcoptions.Value.MongoDbName);
            //获取指定集合   BsonDocument数据库文档对象
            IMongoCollection<BsonDocument> coll = dbs.GetCollection<BsonDocument>("ibeaconlocus");

dotnet add package mongodb.bson
dotnet add package mongodb.driver

"MongodbHost": {
  "Connection": "mongodb://[username]:[password]@[ip]:[port]",
  "DataBase": "[database]",
  "Table": ""
 },

public static MongodbHostOptions MongodbConfig()
{
  var builder = new ConfigurationBuilder()
        .SetBasePath(Directory.GetCurrentDirectory())
        .AddJsonFile("appsettings.json");

　　IConfiguration Configuration = builder.Build();
　　var option = Configuration.GetSection("MongodbHost");
　　return new MongodbHostOptions { Connection = option["Connection"], DataBase = option["DataBase"], Table = option["Table"] };
}

#region FindListByPage 分页查询集合
  /// <summary>
  /// 分页查询集合
  /// </summary>
  /// <param name="filter">查询条件</param>
  /// <param name="pageIndex">当前页</param>
  /// <param name="pageSize">页容量</param>
  /// <param name="count">总条数</param>
  /// <param name="field">要查询的字段,不写时查询全部</param>
  /// <param name="sort">要排序的字段</param>
  /// <returns></returns>
  public static List<T> FindListByPage(FilterDefinition<T> filter, int pageIndex, int pageSize, out int count, string[] field = null, SortDefinition<T> sort = null)
  {
    try
    {
      MongodbHostOptions host = Tools.AppSettingsTools.MongodbConfig();
      host.Table = "WSMessageLog";
      var client = MongodbClient<T>.MongodbInfoClient(host);
      count = Convert.ToInt32(client.CountDocuments(filter));
      //不指定查询字段
      if (field == null || field.Length == 0)
      {
        if (sort == null) return client.Find(filter).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
        //进行排序
        return client.Find(filter).Sort(sort).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
      }

      //指定查询字段
      var fieldList = new List<ProjectionDefinition<T>>();
      for (int i = 0; i < field.Length; i++)
      {
        fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));
      }
      var projection = Builders<T>.Projection.Combine(fieldList);
      fieldList?.Clear();

      //不排序
      if (sort == null) return client.Find(filter).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();

      //排序查询
      return client.Find(filter).Sort(sort).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();

    }
    catch (Exception ex)
　　{
　　　　throw ex;
　　}
}
#endregion

[BsonDateTimeOptions(Kind = DateTimeKind.Local)]
public DateTime logtime { get; set; }

public static LogPager<log_operate> Get_operate_log_mongo(OprLogModel qModel)
{
　　LogPager<log_operate> pager = new LogPager<log_operate>();
　　FilterDefinition<log_operate> filters;

　　 var sortbuilder = Builders<log_operate>.Sort;
　　var sort = sortbuilder.Descending("operate_time");

　　#region 用户权限过滤
　　IEnumerable<string> IdList = dev_deviceRepository.GetBinding(qModel.user_id);
　　 filters = Builders<log_operate>.Filter.In("device_id", IdList);
　　#endregion

　　if (!string.IsNullOrEmpty(qModel.device_id))
  {
  　　var filters_did = Builders<log_operate>.Filter.Eq("device_id", qModel.device_id);
  　　filters = Builders<log_operate>.Filter.And(filters, filters_did);
　　}
　　if (qModel.sDate != null)
　　{
　　　　var filters_sdate = Builders<log_operate>.Filter.Gte<DateTime>("operate_time", Convert.ToDateTime(qModel.sDate));
　　　　filters = Builders<log_operate>.Filter.And(filters, filters_sdate);
　　}
　　if (qModel.eDate != null)
　　{
　　　　var filters_edate = Builders<log_operate>.Filter.Lte<DateTime>("operate_time", Convert.ToDateTime(qModel.eDate));
　　　　filters = Builders<log_operate>.Filter.And(filters, filters_edate);
　　}
　　int total;
　　pager.data = MongoTools<log_operate>.FindListByPage(filters, qModel.pageindex, (qModel.pageindex - 1) * qModel.pagesize, out total, null, sort);
　　pager.total = total;
　　return pager;
}
#endregion

FilterDefinition<log_operate> filters = FilterDefinition<log_operate>.Empty;
var filters_idlist = Builders<log_operate>.Filter.In("device_id", IdList);
filters = Builders<log_operate>.Filter.And(filters, filters_idlist);

• .Net Core中使用MongoDB搭建集群与项目实战
• .Net Core使用MongoDB的详细教程
• asp.net core集成MongoDB的完整步骤
• .net Core连接MongoDB数据库的步骤详解
• MongoDB数据库介绍并用.NET Core对其进行编码

public override async Task<PagerList<NewsContentDto>> PagerQueryAsync(NewsContentQuery parameter)
        {
            FilterDefinitionBuilder<NewsContentDto> builder = Builders<NewsContentDto>.Filter;
            string p = parameter.Keyword == null? $".*{Regex.Escape("")}.*": $".*{Regex.Escape(parameter.Keyword)}.*";
            FilterDefinition <NewsContentDto> filter2 = builder.Regex("title", new BsonRegularExpression(new Regex(p, RegexOptions.IgnoreCase)));
            //var filter1 = Builders<T>.Filter.Regex("title", new BsonRegularExpression(new Regex(".*" + Regex.Escape("英超") + ".*", RegexOptions.IgnoreCase)));
            //var filter1 = Filter.Regex(x => x.EnglishName, new MongoDB.Bson.BsonRegularExpression(parameter.Keyword, "i"));
            //BsonDocument filter = new BsonDocument {{"title", $"/{parameter.Keyword}/" } };
            //if(parameter.classifyId>0) filter.Add("classifyId", parameter.classifyId);
            
            var query = new QueryMongoParameter<NewsContentDto>(parameter, "news_content", filter2);
            var ret = await MongoContext.PagerQueryAsync(query);
            return ret;
        }

public async Task<PagerList<T>> PagerQueryAsync<T>(QueryMongoParameter<T> query)
        {
            var skip = (query.Page - 1) * query.PageSize;
            var collection = _database.GetCollection<T>(query.CollectName);
            var data = await collection.Find(query.Filter).Sort(query.Sort).Project(query.Projection).Skip(skip).Limit(query.PageSize).ToListAsync();
            var total = await collection.CountAsync(query.Filter);
            var ret = new List<T>();
            data.ForEach(d =>
            {
                string s = d.ToString().Replace("\"_id\"", "\"id\"");
                ret.Add(Helpers.Json.ToObject<T>(s));
            });
            return new PagerList<T>(query.Page, query.PageSize, (int)total, ret);
        }

public class PageMongoParameter : ParameterBase
    {
        public BsonDocument Sort { get; }
        public BsonDocument Skip { get; }
        public BsonDocument Limit { get;}        
        public BsonDocument Filter2 { get; }

        public BsonDocument[] Pipeline { get; set; }
        public PageMongoParameter(PageRequest req, string collectName, BsonDocument filter=null,BsonDocument sort=null, BsonDocument filter2 = null)
        {
            CollectName = collectName;
            Page = req.pageindex;
            PageSize = req.pagesize;
            Limit = new BsonDocument { { "$limit", PageSize } };
            Skip = new BsonDocument { { "$skip", (Page-1)*PageSize} };

            if (sort == null)
            {
                if (!string.IsNullOrEmpty(req.order)) Sort = new BsonDocument { { "$sort", new BsonDocument { { req.order, 1 } } } };
            }
            else
            {
                Sort = sort;
            }

            if (filter != null && filter2==null)
            {
                var dom = filter.GetElement(0);
                Filter2 = BsonDocument.Parse(dom.Value.ToJson());
            }
            Filter2 = Filter2 ?? new BsonDocument();

            if (filter == null && Sort == null)
                Pipeline = new[] {Skip, Limit};
            else
            {
                if(filter!=null && Sort != null)
                    Pipeline = new[] { filter,Skip, Limit,Sort };
                else
                    Pipeline = filter == null ? new[] {Skip, Limit, Sort} : new[] { filter,Skip, Limit};
            }
        }
        

    }

public class Db
    {
        private static IMongoDatabase db = null;

        private static readonly object lockHelper = new object();

        private Db() { }

        public static IMongoDatabase GetDb(string connStr, string dbName)
        {
            if (db == null)
            {
                lock (lockHelper)
                {
                    if (db == null)
                    {
                        var client = new MongoClient(connStr);
                        db = client.GetDatabase(dbName);
                    }
                }
            }
            return db;
        }
    }

public class MongoDbHelper<T> where T : MongoBaseEntity, new()
    {
        private IMongoDatabase db = null;
        private IMongoCollection<T> collection = null;
        private readonly IOptions<MongoDBConfig> _options;

        public MongoDbHelper(IOptions<MongoDBConfig> options)
        {
            this._options = options;
            this.db = Db.GetDb(this._options.Value.ConnectionString, this._options.Value.DbName);
            this.collection = db.GetCollection<T>(typeof(T).Name);
        }

        /// <summary>
        /// 分页
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="sort"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public PagingModel<T> GetPagingData(FilterDefinition<T> filter, SortDefinition<T> sort, int pageIndex, int pageSize)
        {
            var list = this.collection
                .Find(filter)
                .Sort(sort)
                .Skip((pageIndex - 1) * pageSize)
                .Limit(pageSize)
                .ToList();

            var count = this.collection.CountDocuments(filter);

            var pagingModel = new PagingModel<T>();
            pagingModel.Items = list;
            pagingModel.PageIndex = pageIndex;
            pagingModel.PageSize = pageSize;
            pagingModel.TotalRecords = Convert.ToInt32(count);
            pagingModel.TotalPages = (int)Math.Ceiling((double)count / (double)pageSize);

            return pagingModel;
        }
    }

"MongoDBConfig": {
    "ConnectionString": "mongodb://xxx:xxx@192.168.3.240:27017",
    "DbName": "xxxDB"
  }

public class MongoDBConfig
    {
        /// <summary>
        /// 数据库连接字符串
        /// </summary>
        public string ConnectionString { get; set; }

        /// <summary>
        /// 具体数据库名称
        /// </summary>
        public string DbName { get; set; }
    }

/// <summary>
    /// 描述：分页实体
    /// 创建人：苏本东
    /// 创建时间：2019-3-5 19:05:20
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class PagingModel<T> where T : class, new()
    {
        /// <summary>
        /// 当前页码
        /// </summary>
        public int PageIndex { get; set; }

        /// <summary>
        /// 每页大小
        /// </summary>
        public int PageSize { get; set; }

        /// <summary>
        /// 总记录数
        /// </summary>
        public int TotalRecords { get; set; }

        /// <summary>
        /// 总页数
        /// </summary>
        public int TotalPages { get; set; }

        /// <summary>
        /// 每页数据
        /// </summary>
        public List<T> Items { get; set; }
    }

FilterDefinition<ModbusData> filter = Builders<ModbusData>.Filter.Empty;
            if (request.Ip.IsNotNullAndEmpty())
            {
                //注意：Eq方法的第一个参数，大小写需要跟数据库一致，不然查询无效
                filter = Builders<ModbusData>.Filter.Eq("IP", request.Ip);
            }

            var sort = Builders<ModbusData>.Sort.Descending(c => c._id);
            var pagingModel = this._mongo.GetPagingData(filter,
                sort,
                (int)request.page,
                (int)request.limit);