windows7下MongoDB（V3.4）的使用及倉儲設計

来源:http://www.cnblogs.com/lianming37/archive/2017/09/28/7606707.html
-Advertisement-
Play Games

簡單的介紹一下，我使用MongoDB的場景。 我們現在的物聯網環境下，有部分數據，採樣頻率為2000條記錄/分鐘，這樣下來一天24*60*2000=2880000約等於300萬條數據，以後必然還會增加。之前資料庫使用的是mssql，對於資料庫的壓力很大，同時又需要保證歷史查詢的響應速度，這種情況下， ...


簡單的介紹一下，我使用MongoDB的場景。

我們現在的物聯網環境下，有部分數據，採樣頻率為2000條記錄/分鐘，這樣下來一天24*60*2000=2880000約等於300萬條數據，以後必然還會增加。之前資料庫使用的是mssql，對於資料庫的壓力很大，同時又需要保證歷史查詢的響應速度，這種情況下，在單表中數據量大，同時存在讀寫操作。不得已採用MongoDB來存儲數據。如果使用MongoDB，則至少需要三台機器，兩台實現讀寫分離，一臺作為仲裁（當然條件不允許也可以不用），每台機器的記憶體暫時配置在16G，公司小，沒辦法，據說，使用這個MongoDB需要機器記憶體最少92G，我沒有驗證過，但是吃記憶體是公認的，所以記憶體絕對要保證，就算保證了，也不一定完全就沒有意外發生。我們上面的這些特殊的數據是允許少量的丟失的，這些只是做分析使用的，幾個月了，暫時還沒出現數據丟失的情況，可能最新版本早就修複了吧，新手使用建議多看下官網上的說明。下麵直接奔入主題：

一、安裝部署和配置環境

1.安裝部署mongo-server（V3.4）

參考http://blog.csdn.net/qq_27093465/article/details/54574948 這個時候不要啟動，接著配置config文件

2.配置Config文件

dbpath=C:/Program Files/MongoDB/Server/3.4/bin/data/db  logpath=C:/Program Files/MongoDB/Server/3.4/bin/data/log/master.log  pidfilepath=C:/Program Files/MongoDB/Server/3.4/bin/master.pid  directoryperdb=true  logappend=true  replSet=testrs  bind_ip=10.1.5.25 port=27016  oplogSize=10000 noauth = true   storageEngine = wiredTiger wiredTigerCacheSizeGB = 2 syncdelay = 30 wiredTigerCollectionBlockCompressor = snappy   以上是詳細的配置參數，其中路徑部分根據需要更改， 這裡設置的oplogsize大小為10G，根據業務場景進行調整，另外auth許可權為null，因為設置許可權會增加服務開銷，影響效率，最下麵幾行是記憶體引擎，可以控制副本集同步及記憶體限制，防止記憶體泄露。

3.啟動mongo-server

4.添加副本集配置

conf= {     "_id" : "testrs",     "members" : [         { "_id" : 0,  "host" : "10.1.5.25:27016"  },         { "_id" : 1,  "host" : "10.1.5.26:27016"  },         { "_id" : 2,  "host" : "10.1.5.27:27016"  }     ] }   rs.initiate(conf) 此時副本集集群配置已經完成，然後在命令行中輸入：rs.status()，查看副本集狀態，需要查看同步情況，可以輸入命令：db.serverStatus().

5.設置副本集可讀寫

Rs.slaveOk()

6..NET操作mongo

連接設置，請參考個人封裝Unitoon.Mongo代碼所示。

7.性能對比

讀寫速度：Redis>Mongo>Mssqlserver 可容納數據量：Mssqlserver~Mongo>Redis 存儲數據類型：Mongo>Mssqlserver>Redis   Note：記憶體持續上升，內部沒有記憶體回收機制，若限制記憶體 ，則可能出現查詢速度變慢，數據丟失等問題，建議優化查詢效率，建立索引 Db.test.ensureIndex({"username":1, "age":-1}) 強制釋放記憶體命令：db.runCommand({closeAllDatabases:1})  

二、倉儲設計

1.基類BaseEntity

namespace UnitoonIot.Mongo
{
    /// <summary>
    /// 實體基類，方便生成ObjId
    /// </summary>
    [Serializable]
    [ProtoContract(ImplicitFields = ImplicitFields.AllPublic)]
   //[ProtoInclude(10, typeof(NormalHistory))]
    public class BaseEntity
    {
        //[BsonRepresentation(BsonType.ObjectId)]
        public ObjectId Id { get; set; }

        /// <summary>
        /// 資料庫名稱
        /// </summary>
        public string DbName { get; set; }

        /// <summary>
        /// 給對象初值
        /// </summary>
        public BaseEntity()
        {
           // this.ObjId = ObjectId.GenerateNewId().ToString();
            //this.Id = ObjectId.NewObjectId().ToString();
        }
    }
}

這裡需要註意時間格式，MongoDB預設時間格式為國際時間，所以在寫入數據時和讀取數據時，時間格式要一致，此例中沒有對時間進行特殊處理，由傳入的時間格式確定。

2.Repository繼承介面IMongoRepository

 

namespace UnitoonIot.Mongo
{
   public interface IMongoRepository<TEntity> where TEntity : class
    {
    }
}

3.MongoRepository

using MongoDB.Driver;
using MongoDB.Bson;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Driver.Linq;
using System.Configuration;
using System.IO;
using UnitoonIot.AppSetting;

namespace UnitoonIot.Mongo
{

    public class MongoDb
    {
        private static  string ConnectionStringHost ;
        private static  string UserName ;
        private static  string Password;
        private static IMongoDatabase _db = null;
        private static readonly object LockHelper = new object();
        /// <summary>
        /// mongodb初始化
        /// </summary>
        public static void Init()
        {
            ConnectionStringHost = "10.1.5.24:27016,10.1.5.24:27016,10.1.5.26:27017";
            //AppSettings.GetConfigValue("MongoHost");//"10.1.5.24:27016";
            UserName = AppSettings.GetConfigValue("MongoUserName");
            Password = AppSettings.GetConfigValue("MongoPwd");
        }
        static MongoDb()
        {
         
        }
       public static IMongoDatabase GetDb(string dbName,string options=null)
        {
        
            if (_db != null) return _db;
            lock (LockHelper)
            {

                if (_db != null) return _db;
                var database = dbName;
                var userName = UserName;
                var password = Password;
                var authentication = string.Empty;
                var host = string.Empty;
                if (!string.IsNullOrWhiteSpace(userName))
                {
                    authentication = string.Concat(userName, ':', password, '@');
                }
                if (!string.IsNullOrEmpty(options) && !options.StartsWith("?"))
                {
                    options = string.Concat('?', options);
                }



                host = string.IsNullOrEmpty(ConnectionStringHost) ? "localhost" : ConnectionStringHost;
                database = database ?? "testdb";
                //mongodb://[username:password@]host1[:port1][,host2[:port2],…[,hostN[:portN]]][/[database][?options]]

                var conString = options!=null? $"mongodb://{authentication}{host}/{database}{options}"
                    : $"mongodb://{authentication}{host}/{database}";

                var url = new MongoUrl(conString);
                var mcs = MongoClientSettings.FromUrl(url);
                mcs.MaxConnectionLifeTime = TimeSpan.FromMilliseconds(1000);
                var client = new MongoClient(mcs);
                             
                _db = client.GetDatabase(url.DatabaseName);
            }
            return _db;
        }
    }
    /// <summary>
    /// MongoDb 資料庫操作類
    /// </summary>
    public class MongoRepository<T>: IMongoRepository<T> where T :  BaseEntity
    {
        #region readonly field
        /// <summary>
        /// 表名
        /// </summary>
        private readonly IMongoCollection<T> _collection = null;
        /// <summary>
        /// 資料庫對象
        /// </summary>
        private readonly IMongoDatabase _database;
        #endregion

        /// <summary>
        /// 構造函數
        /// </summary>
        public MongoRepository()
        {
            this._database = MongoDb.GetDb(Activator.CreateInstance<T>().DbName, "readPreference =secondaryPreferred ");//primaryPreferred/secondaryPreferred/nearest
            _collection = _database.GetCollection<T>(typeof(T).Name);
        }
     

        #region 增加
        /// <summary>
        /// 插入對象
        /// </summary>
        /// <param name="t">插入的對象</param>
        public virtual T Insert(T t)
        {
           // var flag = ObjectId.GenerateNewId();
           // t.GetType().GetProperty("Id").SetValue(t, flag);    
            //t.Time = DateTime.Now;

            _collection.InsertOne(t);
            return t;
        }
        /// <summary>
        /// 批量插入
        /// </summary>
        /// <param name="ts">要插入的對象集合</param>
        public virtual IEnumerable<T> InsertBatch(IEnumerable<T> ts)
        {
            _collection.InsertMany(ts);
            return ts;
        }

        /// <summary>
        /// 插入對象
        /// </summary>
        /// <param name="t">插入的對象</param>
        public virtual  void InsertAsync(T t)
        {
            //var flag = ObjectId.GenerateNewId();
           // t.GetType().GetProperty("Id").SetValue(t, flag);
           // t.Time = DateTime.Now;
             _collection.InsertOneAsync(t);
        }
        /// <summary>
        /// 批量插入
        /// </summary>
        /// <param name="ts">要插入的對象集合</param>
        public virtual void InsertBatchAsync(IEnumerable<T> ts)
        {
             _collection.InsertManyAsync(ts);
        }
        #endregion

        #region 刪除
        /// <summary>
        /// 刪除
        /// </summary>
        /// <returns></returns>
        public virtual long Delete(T t)
        {
            var filter = Builders<T>.Filter.Eq("Id", t.Id);
            var result = _collection.DeleteOne(filter);
            return result.DeletedCount;          
        }
        /// <summary>
        /// 刪除
        /// </summary>
        /// <returns></returns>
        public virtual  void DeleteAsync(T t)
        {
            var filter = Builders<T>.Filter.Eq("Id", t.Id);
            _collection.DeleteOneAsync(filter);
        }

        /// <summary>
        /// 按條件表達式刪除
        /// </summary>
        /// <param name="predicate">條件表達式</param>
        /// <returns></returns>
        public virtual long Delete(Expression<Func<T, bool>> predicate)
        {
            var result = _collection.DeleteOne(predicate);
            return result.DeletedCount;
        }
        /// <summary>
        /// 按條件表達式刪除
        /// </summary>
        /// <param name="predicate">條件表達式</param>
        /// <returns></returns>
        public virtual  void DeleteAsync(Expression<Func<T, bool>> predicate)
        {
           _collection.DeleteOneAsync(predicate);
        }


        /// <summary>
        /// 按條件表達式批量刪除
        /// </summary>
        /// <param name="predicate">條件表達式</param>
        /// <returns></returns>
        public virtual long DeleteBatch(Expression<Func<T, bool>> predicate)
        {
            var result = _collection.DeleteMany(predicate);
            return result.DeletedCount;
        }
        /// <summary>
        /// 按條件表達式批量刪除
        /// </summary>
        /// <param name="predicate">條件表達式</param>
        /// <returns></returns>
        public virtual  void DeleteBatchAsync(Expression<Func<T, bool>> predicate)
        {
             _collection.DeleteManyAsync(predicate);
        }

        /// <summary>
        /// 按檢索條件刪除
        /// 建議用Builders<T>構建複雜的查詢條件
        /// </summary>
        /// <param name="filter">條件</param>
        /// <returns></returns>
        public virtual long Delete(FilterDefinition<T> filter)
        {
            var result = _collection.DeleteOne(filter);
            return result.DeletedCount;
        }

        /// <summary>
        /// 按檢索條件刪除
        /// 建議用Builders<T>構建複雜的查詢條件
        /// </summary>
        /// <param name="filter">條件</param>
        /// <returns></returns>
        public virtual  void DeleteAsync(FilterDefinition<T> filter)
        {
             _collection.DeleteOneAsync(filter);
        }
        #endregion

        #region 修改
        /// <summary>
        /// 修改(Id不變)
        /// </summary>    
        /// <returns></returns>
        public virtual long Update(T t)
        {         
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id",t.Id);
            var update = _collection.ReplaceOne(filter, t, new UpdateOptions() { IsUpsert = true });
            return update.ModifiedCount;
        }
        /// <summary>
        /// 修改(Id不變)
        /// </summary>    
        /// <returns></returns>
        public virtual  void UpdateAsync(T t)
        {
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id", t.Id);
             _collection.ReplaceOneAsync(filter, t, new UpdateOptions() { IsUpsert = true });
            
        }


        /// <summary>
        /// 用新對象替換新文檔
        /// </summary>
        /// <param name="filter">查詢條件</param>
        /// <param name="t">對象</param>
        /// <returns>修改影響文檔數</returns>
        public virtual long Update(Expression<Func<T, bool>> filter, T t)
        {
            var update = _collection.ReplaceOne(filter, t, new UpdateOptions() { IsUpsert = true });
            return update.ModifiedCount;
        }


        /// <summary>
        /// 用新對象替換新文檔
        /// </summary>
        /// <param name="filter">查詢條件</param>
        /// <param name="t">對象</param>
        /// <returns>修改影響文檔數</returns>
        public virtual long Update(FilterDefinition<T> filter, T t)
        {
            var update = _collection.ReplaceOne(filter, t, new UpdateOptions() { IsUpsert = true });
            return update.ModifiedCount;
        }
        /// <summary>
        /// 用新對象替換新文檔
        /// </summary>
        /// <param name="filter">查詢條件</param>
        /// <param name="t">對象</param>
        /// <returns>修改影響文檔數</returns>
        public virtual void UpdateAsync(Expression<Func<T, bool>> filter, T t)
        {
            _collection.ReplaceOneAsync(filter, t, new UpdateOptions() { IsUpsert = true });
          
        }
        /// <summary>
        /// 用新對象替換新文檔
        /// </summary>
        /// <param name="filter">查詢條件</param>
        /// <param name="t">對象</param>
        /// <returns>修改影響文檔數</returns>
        public virtual void UpdateAsync(FilterDefinition<T> filter, T t)
        {
              _collection.ReplaceOneAsync(filter, t, new UpdateOptions() { IsUpsert = true });
            
        }
        /// <summary>
        /// 根據Id和條件文檔
        /// </summary>
        /// <param name="update">修改條件-形如：Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="id">對象Id</param>
        /// <returns>修改影響文檔數</returns>
        public virtual long Update(string id, UpdateDefinition<T> update)
        {
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id", new ObjectId(id));
            var result = _collection.UpdateOne(filter, update, new UpdateOptions() { IsUpsert = true });
            return  result.ModifiedCount;
        }
        /// <summary>
        /// 根據Id和條件文檔
        /// </summary>
        /// <param name="update">修改條件-形如：Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="id">對象Id</param>
        /// <returns>修改影響文檔數</returns>
        public virtual void UpdateAsync(string id, UpdateDefinition<T> update)
        {
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id", new ObjectId(id));
            _collection.UpdateOneAsync(filter, update, new UpdateOptions() { IsUpsert = true });       
        }
        /// <summary>
        /// 根據條件修改文檔
        /// </summary>
        /// <param name="update">修改條件-形如：Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查詢條件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影響文檔數</returns>
        public virtual void Update(UpdateDefinition<T> update,Expression<Func<T, bool>> filter)
        {
            _collection.UpdateOne(filter, update, new UpdateOptions() { IsUpsert = true });
        }
        /// <summary>
        /// 根據條件修改文檔
        /// </summary>
        /// <param name="update">修改條件-形如：Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查詢條件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影響文檔數</returns>
        public virtual long Update(UpdateDefinition<T> update, FilterDefinition<T> filter)
        {
            var result = _collection.UpdateOne(filter, update, new UpdateOptions() { IsUpsert = true });
            return result.ModifiedCount;
        }
        /// <summary>
        /// 根據條件修改文檔
        /// </summary>
        /// <param name="update">修改條件-形如：Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查詢條件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影響文檔數</returns>
        public virtual void UpdateAsync(UpdateDefinition<T> update, Expression<Func<T, bool>> filter)
        {
            _collection.UpdateOneAsync(filter, update, new UpdateOptions() { IsUpsert = true });
        }
        /// <summary>
        /// 根據條件修改文檔
        /// </summary>
        /// <param name="update">修改條件-形如：Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查詢條件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影響文檔數</returns>
        public virtual void  UpdateAsync(UpdateDefinition<T> update, FilterDefinition<T> filter)
        {
             _collection.UpdateOneAsync(filter, update, new UpdateOptions() { IsUpsert = true });
        }

        /// <summary>
        /// 根據條件批量修改文檔
        /// </summary>
        /// <param name="update">修改條件-形如：Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查詢條件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影響文檔數</returns>
        public virtual long UpdateBatch(UpdateDefinition<T> update, Expression<Func<T, bool>> filter)
        {
            var result = _collection.UpdateMany(filter, update, new UpdateOptions() { IsUpsert = true });
            return result.ModifiedCount;
        }

        /// <summary>
        /// 根據條件批量修改文檔
        /// </summary>
        /// <param name="update">修改條件-形如：Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查詢條件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影響文檔數</returns>
        public virtual long UpdateBatch(UpdateDefinition<T> update, FilterDefinition<T> filter)
        {
            var result = _collection.UpdateMany(filter, update, new UpdateOptions() { IsUpsert = true });
            return result.ModifiedCount;
        }
        /// <summary>
        /// 根據條件批量修改文檔
        /// </summary>
        /// <param name="update">修改條件-形如：Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查詢條件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影響文檔數</returns>
        public virtual void UpdateBatchAsync(UpdateDefinition<T> update, Expression<Func<T, bool>> filter)
        {
             _collection.UpdateManyAsync(filter, update, new UpdateOptions() { IsUpsert = true });
        }

        /// <summary>
        /// 根據條件批量修改文檔
        /// </summary>
        /// <param name="update">修改條件-形如：Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查詢條件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影響文檔數</returns>
        public virtual void UpdateBatchAsync(UpdateDefinition<T> update, FilterDefinition<T> filter)
        {
            _collection.UpdateManyAsync(filter, update, new UpdateOptions() { IsUpsert = true });
        }
        #endregion

        #region 查詢 

        #region GetCollection

        /// <summary>
        /// 獲取操作對象的IMongoCollection集合,強類型對象集合
        /// </summary>
        /// <returns></returns>
        public virtual IMongoCollection<T> GetCollection()
        {
            return _database.GetCollection<T>(typeof(T).Name);
        }

        #endregion

        #region GetSingle
        /// <summary>
        /// 查詢資料庫,檢查是否存在指定ID的對象
        /// </summary>
        /// <param name="id">對象的ID值</param>
        /// <returns>存在則返回指定的對象,否則返回Null</returns>
        public virtual T GetById(string id)
        {
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id", new ObjectId(id));
            var data = _collection.Find(filter).FirstOrDefault();
            return data;
        }
        /// <summary>
        /// 查詢資料庫,檢查是否存在指定ID的對象
        /// </summary>
        /// <param name="id">對象的ID值</param>
        /// <returns>存在則返回指定的對象,否則返回Null</returns>
        public virtual async Task<T> GetAsyncById(string id)
        {
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id", new ObjectId(id));
            var data = await _collection.FindAsync(filter);
            return await data.SingleOrDefaultAsync();
        }
        /// <summary>
        /// 查詢數據
        /// </summary>
        /// <param name="filter">過濾條件</param>
        /// <returns></returns>
        public virtual T Get(FilterDefinition<T> filter)
        {
            return _collection.Find(filter).FirstOrDefault();
        }
        /// <summary>
        /// 查詢數據
        /// </summary>
        /// <param name="filter">條件表達式</param>
        /// <returns></returns>
        public virtual T Get(Expression<Func<T,bool>> filter)
        {
            return _collection.Find(filter).FirstOrDefault();
        }
        /// <summary>
        /// 查詢數據
        /// </summary>
        /// <param name="filter">過濾條件</param>
        /// <returns></returns>
        public virtual async Task<T> GetAsync(FilterDefinition<T> filter)
        {
            var data = await _collection.FindAsync(filter);
            return await data.SingleOrDefaultAsync();
        }
        /// <summary>
        /// 查詢數據
        /// </summary>
        /// <param name="filter">條件表達式</param>
        /// <returns></returns>
        public virtual async Task<T> GetAsync(Expression<Func<T, bool>> filter)
        {
            var data = await _collection.FindAsync(filter);
            return await data.SingleOrDefaultAsync();
        }


        #endregion

        #region GetMany
        /// <summary>
        /// 查詢部分數據
        /// </summary>
        /// <param name="filter">過濾條件</param>
        /// <returns></returns>
        public virtual IEnumerable<T> GetMany(FilterDefinition<T> filter)
        {
            return _collection.Find(filter).ToEnumerable();
        }

        /// <summary>
        /// 查詢部分數據
        /// </summary>
        /// <param name="filter">條件表達式</param>
        /// <returns></returns>
        public virtual IEnumerable<T> GetMany(Expression<Func<T,bool>> filter)
        {
            //return _collection.AsQueryable().Where(filter).ToList();
            //return _collection.AsQueryable().Where(filter);
            return _collection.Find(filter).ToEnumerable(); //.ToEnumerable(); 
        }

        /// <summary>
        /// 查詢部分數據
        /// </summary>
        /// <param name="filter">過濾條件</param>
        /// <returns></returns>
        public virtual async Task<IEnumerable<T>> GetManyAsync(FilterDefinition<T> filter)
        {
            var data = await _collection.FindAsync(filter);
            return await data.ToListAsync();
        }

        /// <summary>
        /// 查詢部分數據
        /// </summary>
        /// <param name="filter">過濾條件</param>
        /// <returns></returns>
        public virtual async Task<IEnumerable<T>> GetManyAsync(Expression<Func<T, bool>> filter)
        {
            var data = await _collection.FindAsync(filter);
            return await data.ToListAsync();
        }
        
        #endregion

        #region GetAll

        /// <summary>
        /// 查詢所有記錄，複雜查詢直接用Linq處理(避免全表掃描)
        /// </summary>
        /// <returns>要查詢的對象</returns>
        public virtual IEnumerable<T> GetAll()
        {
            var data = _collection.AsQueryable();
            return data.ToEnumerable();
        }
        /// <summary>
        /// 查詢所有記錄，複雜查詢直接用Linq處理(避免全表掃描)
        /// </summary>
        /// <returns>要查詢的對象</returns>
        public virtual async Task<IEnumerable<T>> GetAllAsync()
        {
            var data =  _collection.AsQueryable();
            return await data.ToListAsync();
        }

        /// <summary>
        /// 查詢所有記錄，複雜查詢直接用Linq處理(避免全表掃描)
        /// </summary>
        /// <returns>要查詢的對象</returns>
        public virtual IQueryable<T> GetAllQueryable()
        {
            return _collection.AsQueryable();
        }

        #endregion

        #region MapReduce
        /// <summary>  
        ///  MapReduce
        /// </summary>     
       /// <returns>返回一個List列表數據</returns>  
        public IEnumerable<T> GetMap(BsonJavaScript map,BsonJavaScript reduce)
        {
            return  _collection.MapReduce<T>(map,reduce).ToList();
        }


        #endregion

        #endregion
    }

}

好了，就介紹到這裡。  
您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 日期小demo
    有個項目需求是做個在日期上選擇的,就是這種: 網上看了幾個日期的demo都太厚重了,移植起來太麻煩,然後打算自己寫。 就先寫個簡化的demo看看,主要有幾個關鍵點: 首先要根據當前日期獲取這個月有幾天 然後判斷這個月份第一天是周幾 再根據上面兩個數據在合理的位置顯示數據 還要記錄下當前的日期方便切換 ...
  • SparkSQL和DataFrame
    SparkSQL和DataFrame SparkSQL簡介 Spark SQL是Spark用來處理結構化數據的一個模塊，它提供了一個編程抽象叫做DataFrame並且作為分散式SQL查詢引擎的作用。它是將Spark SQL轉換成RDD，然後提交到集群執行，執行效率非常快！ SparkSQL的特性 1 ...
  • Mysql相關操作
    1》創建資料庫： 語法：create database 資料庫名; 語法：show databases 查看已經存在資料庫 舉例： Mysql->create database zytest; 註意每一條要以;號結尾 Mysql->show databases;查詢是否創建成功 >use zytes ...
  • orcale 把日期當做查詢條件
    根據日期查詢範圍 精確到天 select * from table where to_char( time,'yyyy mm dd ' ) <= '2000 01 01' select * from table where to_char( time,'yyyy-mm-dd ' ) <= '2000 ...
  • zookeeper集群環境配置
    環境參數如下: 伺服器操作系統: Red Hat Enterpriser Linux 6.5 三台(IP地址分別為:192.168.5.128,192.168.5.129,192.168.5.130) zookeeper版本: zookeeper-3.4.10 JDK版本: jdk1.8.0_144 ...
  • [Oracle]獲得PDB相關的xml 文件
    問題：客戶進行了PDB的克隆之後，發現啟動時出現：ORA-44777: Pluggable database service cannot be started.分析手段：為了獲得PDB的相關信息，可以在 克隆的源和目的機器上分別查詢： exec dbms_pdb.describe('/home/o ...
  • PHP 註釋 數據類型 變數的定義/輸出 類型的獲取/轉換 可變變數
    註釋方法： 1，單行註釋： // 2, 多行註釋： /* */ 二，數據類型 1，integer（整數型）：在三十二位操作系統中它的有效範圍是：-2147483648~+2147483648； 2，string（字元串）：字元串變數不同於其他編程語言有字元與字元串之分，在PHP中統一使用字元型變數來 ...
  • [SqlServer]阻止保存要求重新創建表的更改
    1 概述 1 概述 阻止保存要求重新創建表的更改，場景是這樣的：假設資料庫中有一張員工表EmployeeInfo，如下所示： 其中有個欄位EmployeeBirthday,在設計表時，其類型誤設為VARCHAR類型，此時需要更改其數據類型，即VARCHAR類型更改為DateTime類型，SqlSer ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類