MongoDbHelper 帮助类(下)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MongoDB.Driver;
using MongoDB.Bson;
using MongoDB.Driver.Builders;
using System.Text.RegularExpressions;
namespace Web.MondbHelp
{
/// <summary>
/// mongodb的封装类。
/// </summary>
public class MongoDBHelper<T>
{
//获取web.config中的配置
public static readonly string connectionString_Default = System.Configuration.ConfigurationManager.AppSettings["ConnectionString_mongoDB"];// mongodb://192.168.1.103:27017/test
public static readonly string database_Default = System.Configuration.ConfigurationManager.AppSettings["Database_mongoDB"]; //test

#region MongoService
private string Database { get { return database_Default; } }
private string Connection { get { return connectionString_Default; } }

private string collectName
{
get
{
return typeof(T).Name;
}
}

private MongoServer GetService(string conn)
{
var client = new MongoClient(conn);
return client.GetServer();
}

protected MongoServer GetServer()
{
return GetService(Connection);
}
protected MongoDatabase GetDatabase()
{
return GetServer().GetDatabase(Database);
}

public MongoCollection GetCollection()
{
var service = GetServer();
var database = GetDatabase();
//using (service.RequestStart(database))
//{
//    MongoCollection<T> mycollection = database.GetCollection<T>(collectName);
//    return mycollection;
//}

if (!database.CollectionExists(collectName))
database.CreateCollection(collectName);
return database.GetCollection(collectName);
}
#endregion

#region 自己重新封装方法
#region 保存
/// <summary>
/// 添加
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
protected bool Insert(T t)
{
var result = GetCollection().Insert<T>(t);
return result.Ok;
}

protected void BatchInsert(IList<T> list)
{
GetCollection().InsertBatch(list);
}

protected bool Save(T t)
{
var result = GetCollection().Save<T>(t);
return result.Ok;
}
#endregion
#region 修改
protected bool Update(IMongoQuery query, IMongoUpdate update, UpdateFlags flags = UpdateFlags.None)
{
var result = GetCollection().Update(query, update, flags);
return result.Ok;
}
protected bool Update(string id, T t)
{
var doc = new UpdateDocument(BsonExtensionMethods.ToBsonDocument(t));
return GetCollection().Update(Query.EQ("_id", id), doc).Ok;
}
protected bool FindAndModify(string id, Dictionary<string, object> Updates)
{
UpdateBuilder builder = null;
foreach (var v in Updates)
{
BsonValue value = v.Value.ToString();
builder.AddToSet(v.Key, value.AsBsonValue);//此处的转换错误一直没解决掉
}
return GetCollection().Update(Query.EQ("_id", id), builder).Ok;
}
//protected bool Update(string[] ids, Dictionary<string, object> updates)
//{
//    return GetCollection().FindAndModify .FindAndModify<T>(Query.In("_id", ToBsonArray(ids)), updates);
//}
//protected bool Update(string[] ids, string field, object value)
//{
//    return Update(ids, new Dictionary<string, object> { { field, value } });
//}
//protected bool Update(string id, string field, object value)
//{
//    return Update(id, new Dictionary<string, object> { { field, value } });
//}
//protected bool Update(string id, Dictionary<string, object> updates)
//{
//    return GetCollection().FindAndModify<T>(id, updates);
//}
#endregion
#region 删除
protected bool Remove(IMongoQuery query)
{
var result = GetCollection().Remove(query);
return result.Ok;
}
protected void RemoveByIds(string[] ids)
{
var query = Query.In("_id", ToBsonArray(ids));
GetCollection().Remove(query);
}
protected void RemoveById(string id)
{
RemoveByIds(new string[1] { id });
}
#endregion
#region 查询
/// <summary>
/// 判断数据是否存在
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
protected bool IsExists(string id)
{
return Count(Query.EQ("_id", id)) > 0;
}

/// <summary>
/// 查询数量
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
protected long Count(IMongoQuery query)
{
return GetCollection().Count(query);
}
protected IList<BsonValue> Distict(string key, IMongoQuery query)
{
return GetCollection().Distinct(key, query).ToList();
}
protected T FindOneById(string id, params string[] fields)
{
var query = Query.EQ("_id", id);
return FindOne(query, fields);
}
public T FindOne(IMongoQuery query, params string[] fields)
{
var result = Find(1, query, SortBy.Null, fields);
if (result.Count > 0)
{
return result.FirstOrDefault();
}
return default(T);
}
public IList<T> FindAll(params string[] fields)
{
var cursor = GetCollection().FindAllAs<T>().SetFlags(QueryFlags.NoCursorTimeout);
if (fields != null && fields.Length > 0)
{
cursor.SetFields(fields);
}
return cursor.ToList();
}
public IList<T> FindByIds(IEnumerable<string> ids, params string[] fields)
{
return Find(Query.In("_id", ToBsonArray(ids)));
}
protected IList<T> Find(IMongoQuery query, params string[] fields)
{
return Find(query, SortBy.Null, fields);
}
protected IList<T> Find(IMongoQuery query, IMongoSortBy sortBy, params string[] fields)
{
return Find(0, query, sortBy, fields);
}
protected IList<T> Find(int topCount, IMongoQuery query, params string[] fields)
{
return Find(topCount, query, fields);
}
protected IList<T> Find(int topCount, IMongoQuery query, IMongoSortBy sortBy, params string[] fields)
{
var cursor = GetCollection().FindAs<T>(query);
if (topCount > 0)
{
cursor.SetLimit(topCount);
}
if (sortBy != null && sortBy != SortBy.Null)
{
cursor.SetSortOrder(sortBy);
}
if (fields != null && fields.Length > 0)
{
cursor.SetFields(fields);
}
return cursor.ToList();
}
#endregion
#region 分页
/// <summary>
///  数据量大时 性能不好
/// </summary>
/// <param name="query"></param>
/// <param name="sortBy"></param>
/// <param name="page"></param>
/// <param name="size"></param>
/// <param name="totalCount"></param>
/// <param name="fields"></param>
/// <returns></returns>
protected IList<T> FindPage(IMongoQuery query, IMongoSortBy sortBy, int page, int size, out long totalCount, params string[] fields)
{
int skipCount = 0;
if (page > 1)
skipCount = (page - 1) * size;
else
page = 1;

totalCount = Count(query);
var list = new List<T>();

if (totalCount > 0)
list = GetCollection().FindAs<T>(query).SetFlags(QueryFlags.NoCursorTimeout).SetSortOrder(sortBy).SetSkip(skipCount).SetLimit(size).SetFields(fields).ToList();
return list;
}

protected IList<T> FindPage(string lastObjId, IMongoQuery query, int pageSize,
out long totalCount, params string[] fields)
{
return FindPage(lastObjId, query, pageSize, out totalCount, true, fields);
}
protected IList<T> FindPage(string lastObjId, IMongoQuery query, int pageSize, params string[] fields)
{
long totalCount;
return FindPage(lastObjId, query, pageSize, out totalCount, false, fields);
}

/// <summary>
/// 获取前一页的最后一条记录，查询之后的指定条记录
/// </summary>
/// <param name="lastObjId">首次加载为string.Emtpy,当前页最后一条数据的Id</param>
/// <param name="query"></param>
/// <param name="size"></param>
/// <param name="totalCount"></param>
/// <param name="isOutTotalCount"></param>
/// <param name="fields"></param>
/// <returns></returns>
protected IList<T> FindPage(string lastObjId, IMongoQuery query, int size, out long totalCount, bool isOutTotalCount, params string[] fields)
{
var pQuery = Query.Exists("_id");

if (!string.IsNullOrEmpty(lastObjId))
{
pQuery = Query.And(pQuery, Query.LT("_id", lastObjId));
}
pQuery = Query.And(pQuery, query);
var cursor = Find(size, query, SortBy.Descending("_id"), fields);
if (isOutTotalCount)
{
totalCount = Count(query);
}
else
{
totalCount = 0;
}
return cursor.ToList();
}
#endregion
#region 分组
protected IList<BsonDocument> Group(GroupArgs args)
{
return GetCollection().Group(args).ToList();
}
#endregion
#region MapReduce
protected MapReduceResult MapReduce(MapReduceArgs args)
{
return GetCollection().MapReduce(args);
}
#endregion
#region 封装的方法
/// <summary>
///  CreateRegex
/// </summary>
/// <param name="reg"></param>
/// <param name="regOpt"></param>
/// <returns></returns>
protected Regex CreateRegex(string reg, RegexOptions regOpt = RegexOptions.IgnoreCase)
{
return new Regex(reg, regOpt);
}
/// <summary>
/// 转BsonArray类型
/// </summary>
/// <param name="list"></param>
/// <returns></returns>
protected BsonArray ToBsonArray(System.Collections.IEnumerable list)
{
return new BsonArray(list);
}
public IList<BsonDocument> Group(IMongoQuery query, string key, BsonDocument initial, string reduce, string finalize = "")
{
return this.GetCollection().Group(query, new BsonJavaScript(key), initial, new BsonJavaScript(reduce), new BsonJavaScript(finalize)).ToList();
}
#endregion
#endregion
}
}