windows7下MongoDB（V3.4）的使用及仓储设计

lihu129c

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>　　
{
　　
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>　　
{
　　
#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>　　
{
　　
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>　　
{
　　
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>　　
{
　　
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>　　
{
　　
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
　　
}
　　

　　
}