日前从公司离职，很快，还没休息就步入了现在的公司，开始跟着公司的脚步走。
公司的项目基本都是大数据的，所以在数据库上大部分都是使用Mongodb和Redis，基本都是Nosql型的数据库为主。以前自己学着做过Mongodb和Redis的Demo，大体知道其怎么去运用，只是没有一个规范化的封装和运用，单纯是学习。现在有实战项目了，就激起了我前进学习的心，趁着今天自己查了下一些资料，学习了借鉴了一些前辈的方法后自己也封装了一个Mongdb的底层通用类，这里分享出来跟大家一起学习下。
这里主要是讲我封装的底层，不涉及到Mongodb的安装，启动，可视化查询等东西，后面会附上一些参考的地址供大家一起学习。
目前mongodb提供的驱动主要有两种：
1.官网驱动 下载地址：http://github.com/mongodb/mongo-csharp-driver/downloads
2.第三方的samus驱动 下载地址：https://github.com/samus/mongodb-csharp
两个驱动的运用自己都有使用过，个人感觉官方的驱动提供的方法比较多，用起来也比较顺手，而且更新度比samus的高，所以自己使用的是官方的驱动。
官网驱动的简单使用
主要使用下面的两个dll
MongoDB.dll 驱动的主要程序
MongoDB.GridFS.dll 用于存储大文件。
基本的增删改查代码如下：
//数据库连接字符串
const string strconn = "mongodb://127.0.0.1:27017";
//数据库名称
const string dbName = "cnblogs";
//定义数据库
MongoDatabase db;
/// <summary>
/// 打开数据库链接
/// </summary>
public void GetConnection()
{
//定义Mongo服务
Mongo mongo = new Mongo(strconn);
//打开连接
mongo.Connect();
//获得数据库cnblogs,若不存在则自动创建
db = mongo.GetDatabase(dbName) as MongoDatabase;
}
/// <summary>
/// 添加数据
/// </summary>
public void Insert()
{
var col = db.GetCollection<Users>();
//或者
//var col = db.GetCollection("Users");
Users users = new Users();
users.Name = "xumingxiang";
users.Sex = "man";
col.Insert(users);
}
/// <summary>
/// 更新数据
/// </summary>
public void Update()
{
var col = db.GetCollection<Users>();
//查出Name值为xumingxiang的第一条记录
Users users = col.FindOne(x => x.Name == "xumingxiang");
//或者
//Users users = col.FindOne(new Document { { "Name", "xumingxiang" } });
users.Sex = "women";
col.Update(users, x => x.Sex == "man");
}
/// <summary>
/// 删除数据
/// </summary>
public void Delete()
{
var col = db.GetCollection<Users>();
col.Remove(x => x.Sex == "man");
////或者
////查出Name值为xumingxiang的第一条记录
//Users users = col.FindOne(x => x.Sex == "man");
//col.Remove(users);
}
/// <summary>
/// 查询数据
/// </summary>
public void Query()
{
var col = db.GetCollection<Users>();
var query = new Document { { "Name", "xumingxiang" } };
//查询指定查询条件的全部数据
var result1 = col.Find(query);
//查询指定查询条件的第一条数据
var result2 = col.FindOne(query);
//查询全部集合里的数据
var result3 = col.FindAll();
}
封装扩展使用
1.数据库配置文件
考虑到一个项目里面可能使用到不同的数据库（比如：普通数据和文件数据等分别存到不同数据库中），也有可能会跨服务器查询，所以这里首先创建一个配置文件帮助类，主要是可以进行多个数据库配置，满足跨服务器，跨数据的需求。
配置格式如下：
<?xml version="1.0" encoding="utf-8" ?>
<ServiceConfig>
<mongodbs>
<Item dbName="myDb" hostName="mongodb://127.0.0.1:27017"></Item>
<Item dbName="myDb1" hostName="mongodb://127.0.0.1:27017"></Item>
<Item dbName="myDb2" hostName="mongodb://127.0.0.1:27017"></Item>
</mongodbs>
</ServiceConfig>
Xml序列化对象类
public class ServiceConfig
{
[XmlArray, XmlArrayItem("Item")]
public List<mongodbConfig> mongodbs { get; set; }
}
[XmlRoot]
public class mongodbConfig
{
[XmlAttribute("dbName")]
public string dbName { get; set; }
[XmlAttribute("hostName")]
public string hostName { get; set; }
}
读取配置文件管理类
public class ManagerConfig
{
public static string ConfigPath;
//加载配置文件
static ManagerConfig()
{
ConfigPath = "./config.xml";
}
//xml序列化后的对象
private static ServiceConfig _settings;
public static ServiceConfig ServiceSettings
{
get
{
return _settings ?? (_settings = Load());
}
}
//加载xml序列化为ServiceConfig对象
static ServiceConfig Load()
{
if (File.Exists(ConfigPath))
{
using (FileStream fs = new FileStream(ConfigPath, FileMode.Open))
{
XmlSerializer xs = new XmlSerializer(typeof(ServiceConfig));
//序列化为一个对象
_settings = (ServiceConfig)xs.Deserialize(fs);
}
}
else
{
throw new Exception("数据库配置文件不存在，请检查");
//_settings = new ServiceConfig();
}
return _settings;
}
}
2.实体通用接口
mongodb中本身没有自增ID的属性，自带有一个ObjectID，为了统一每个实体对象都有这个ID ，这里建立一个通用接口和一个底层实体基类来进行规范化处理
实体接口
public interface IMongoEntity
{
string Id { get; }
}
底层实体基类
public class BaseModel : IMongoEntity
{
[BsonIgnore]
public string Id
{
get
{
if (_id == ObjectId.Empty)
_id = ObjectId.GenerateNewId(DateTime.Now);
return _id.ToString();
}
}
[BsonId]
private ObjectId _id;
}
实体类的例子（继承于BaseModel类）
public class UserEntity : BaseModel
{
public string UserName { get; set; }
public int Num { get; set; }
//MongoDB中存储的时间是标准时间UTC +0:00 (相差了8个小时)
[BsonDateTimeOptions(Kind = DateTimeKind.Local)]
public DateTime PostTime { get; set; }
}
3.Mongodb通用帮助基类 （主要类）
public class MongodbBase<T> where T : class,IMongoEntity
{
protected MongoServer server = null;
protected MongoDatabase db = null;
protected MongoCollection<T> collection;
protected void Init(string DbName)
{
var Item = ManagerConfig.ServiceSettings.mongodbs.Where(p => p.dbName == DbName).FirstOrDefault();
if (Item == null)
{
throw new Exception("不存在数据库为: " + DbName + " 的配置对象，请检查");
}
else
{
server = MongoDB.Driver.MongoServer.Create(Item.hostName);
db = server.GetDatabase(Item.dbName);
collection = db.GetCollection<T>(typeof(T).Name.Replace("Entity", ""));
}
}
#region 查询
/// <summary>
/// 根据ID获取对象
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public T GetModelById(string id)
{
return collection.FindOneById(id);
}
/// <summary>
/// 获取一条记录(自定义条件)
/// </summary>
/// <returns></returns>
public T FirstOrDefault(Expression<Func<T, bool>> expression)
{
MongoDB.Driver.IMongoQuery query = Query<T>.Where(expression);
return collection.FindOne(query);
}
/// <summary>
/// 获取一条记录
/// </summary>
/// <returns></returns>
public T FirstOrDefault()
{
return collection.FindAll().FirstOrDefault();
}
/// <summary>
/// 获取全部
/// </summary>
/// <returns></returns>
public List<T> FindAll()
{
return collection.FindAll().ToList();
}
/// <summary>
/// 获取全部(自定义条件)
/// </summary>
/// <returns></returns>
public List<T> FindAll(Expression<Func<T, bool>> expression)
{
MongoDB.Driver.IMongoQuery query = Query<T>.Where(expression);
return collection.Find(query).ToList();
}
/// <summary>
/// 根据条件获取数量
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
public long GetCount(Expression<Func<T, bool>> expression = null)
{
if (expression == null)
{
return collection.Count();
}
else
{
return collection.Count(Query<T>.Where(expression));
}
}
/// <summary>
/// 根据ID判断是否存在
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public bool Exists(string id)
{
return collection.FindOneById(id) != null;
}
/// <summary>
/// 分页
/// </summary>
/// <param name="PageIndex">总页码</param>
/// <param name="PageSize">页容量</param>
/// <param name="RowCounts">总记录数</param>
/// <param name="expression">条件</param>
/// <param name="IsAsc">是否是正序</param>
/// <param name="OrderFiled">排序的字段</param>
/// <returns></returns>
public List<T> Page(int PageIndex, int PageSize, out long RowCounts, Expression<Func<T, bool>> expression = null, bool IsAsc = true, params string[] OrderFiled)
{
MongoCursor<T> mongoCursor;
//条件选择
if (expression != null)
{
RowCounts = collection.Find(Query<T>.Where(expression)).Count();
mongoCursor = collection.Find(Query<T>.Where(expression));
}
else
{
RowCounts = collection.FindAll().Count();
mongoCursor = collection.FindAll();
}
//排序
if (OrderFiled != null && OrderFiled.Length > 0)
{
//处理主键字段
for (int i = 0; i < OrderFiled.Length; i++)
{
if (OrderFiled[i].Equals("id", StringComparison.CurrentCultureIgnoreCase))
{
OrderFiled[i] = "_id";
}
}
if (IsAsc)
{
mongoCursor = mongoCursor.SetSortOrder(SortBy.Ascending(OrderFiled));
}
else
{
mongoCursor = mongoCursor.SetSortOrder(SortBy.Descending(OrderFiled));
}
}
return mongoCursor.SetSkip((PageIndex - 1) * PageSize).SetLimit(PageSize).ToList();
}
#region 效率低，暂时不用
///// <summary>
///// 分页
///// </summary>
///// <returns></returns>
//public List<T> Page(int PageIndex, int PageSize, out long RowCounts, Expression<Func<T, bool>> expression = null)
//{
// List<T> ret = new List<T>();
// IQueryable<T> queryable;
// //条件选择
// if (expression != null)
// {
// queryable = collection.Find(Query<T>.Where(expression)).AsQueryable();
// }
// else
// {
// queryable = collection.FindAll().AsQueryable();
// }
// RowCounts = queryable.Count();
// ret = queryable.Skip((PageIndex - 1) * PageSize).Take(PageSize).ToList();
// return ret;
//}
///// <summary>
///// 分页
///// </summary>
///// <typeparam name="TKey"></typeparam>
///// <param name="PageIndex"></param>
///// <param name="PageSize"></param>
///// <param name="RowCounts"></param>
///// <param name="expression"></param>
///// <param name="orderBy"></param>
///// <param name="IsOrder"></param>
///// <returns></returns>
//public List<T> Page<TKey>(int PageIndex, int PageSize, out long RowCounts, Expression<Func<T, bool>> expression = null, Expression<Func<T, TKey>> orderBy = null, bool IsOrder = true)
//{
// List<T> ret = new List<T>();
// IQueryable<T> queryable;
// //条件选择
// if (expression != null)
// {
// queryable = collection.Find(Query<T>.Where(expression)).AsQueryable();
// }
// else
// {
// queryable = collection.FindAll().AsQueryable();
// }
// //排序
// if (orderBy != null)
// {
// if (IsOrder)
// {
// queryable = queryable.OrderBy(orderBy);
// }
// else
// {
// queryable = queryable.OrderByDescending(orderBy);
// }
// }
// RowCounts = queryable.Count();
// ret = queryable.Skip((PageIndex - 1) * PageSize).Take(PageSize).ToList();
// return ret;
//}
#endregion
#endregion
#region 删除
/// <summary>
/// 带条件的删除
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
public void Delete(Expression<Func<T, bool>> expression)
{
MongoDB.Driver.IMongoQuery query = Query<T>.Where(expression);
var result = collection.Remove(query);
}
/// <summary>
/// 根据模型删除
/// </summary>
/// <param name="model"></param>
public void Delete(T model)
{
MongoDB.Driver.IMongoQuery query = Query<T>.Where(p => p.Id == model.Id);
collection.Remove(query);
}
/// <summary>
/// 根据ID删除
/// </summary>
/// <param name="Id"></param>
public void Delete(string Id)
{
MongoDB.Driver.IMongoQuery query = Query<T>.Where(p => p.Id == Id);
collection.Remove(query);
}
/// <summary>
/// 全部删除
/// </summary>
/// <returns></returns>
public void DeleteAll()
{
var result = collection.RemoveAll();
}
#endregion
#region 添加
/// <summary>
/// 单模型添加
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public void Insert(T model)
{
var result = collection.Insert<T>(model);
}
/// <summary>
/// 批量添加
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public void InsertBatch(List<T> model)
{
collection.InsertBatch<T>(model);
}
#endregion
#region 修改
/// <summary>
/// 修改
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public void Update(T model)
{
var result = collection.Save<T>(model);
}
/// <summary>
/// 批量修改
/// </summary>
/// <param name="model"></param>
public void UpdateAll(List<T> model)
{
model.ForEach(e => collection.Save<T>(e));
}
#endregion
}
4.业务类
当新建一个表（mongodb里面叫做集合），需要对其进行操作，包括一些业务处理时。首先继承MongodbBase类，然后使用Init方法初始化对象，如下面的UserServcices类
public class UserServices : MongodbBase<UserEntity>
{
public UserServices()
{
this.Init("myDb");
}
}
5.使用
[TestClass]
public class UnitTest1
{
Random rd = new Random();
UserServices ubll = new UserServices();
#region 添加
[TestMethod]
public void 添加()
{
UserEntity model = new UserEntity();
model.UserName = "Name" + rd.Next(100, 10000);
model.Num = rd.Next(100, 10000);
model.PostTime = DateTime.Now;
ubll.Insert(model);
}
[TestMethod]
public void 添加复杂模型()
{
ComplexEntity model = new ComplexEntity();
ComplexServices cbll = new ComplexServices();
model.Name = "Complex";
model.Schools = new List<School>();
model.Schools.Add(new School()
{
Master = new Grade()
{
Name = "Master"
},
Name = "School",
Students = new List<Student>()
});
model.Schools[0].Students.Add(new Student() { Age = 22, Name = "张三" });
cbll.Insert(model);
}
[TestMethod]
public void 批量添加()
{
List<UserEntity> Data = new List<UserEntity>();
for (int i = 0; i < 1000000; i++)
{
UserEntity model = new UserEntity();
model.UserName = "Name" + rd.Next(100, 10000);
model.Num = rd.Next(100, 10000);
model.PostTime = DateTime.Now;
Data.Add(model);
}
ubll.InsertBatch(Data);
}
#endregion
#region 修改
[TestMethod]
public void 获取单个对象_修改()
{
var model = ubll.FirstOrDefault(p => p.Id != "");
model.UserName = "new1";
ubll.Update(model);
}
[TestMethod]
public void 批量修改()
{
var model = ubll.FindAll();
for (int i = 0; i < model.Count; i++)
{
model[i].UserName = "Text";
}
ubll.UpdateAll(model);
}
#endregion
#region 查询
[TestMethod]
public void 获取全部对象()
{
var model = ubll.FindAll();
var count = model.Count;
}
[TestMethod]
public void 获取单个对象()
{
var model = ubll.FirstOrDefault();
var count = model.PostTime;
}
[TestMethod]
public void 根据ID获取对象()
{
var model = ubll.GetModelById("eeef22d6-7ac6-40cd-9312-59ab15fd904a");
}
[TestMethod]
public void 获取全部对条件象_带条件()
{
var model = ubll.FindAll(p => p.UserName.Contains("Name"));
var count = model.Count;
}
[TestMethod]
public void 分页()
{
long Rows;
List<UserEntity> pageDate = new List<UserEntity>();
pageDate = ubll.Page(300, 20, out Rows, p => p.Num > 1500);
pageDate = ubll.Page(1, 20, out Rows, null, true, "Id");
pageDate = ubll.Page(1, 20, out Rows, null, true, "Num");
pageDate = ubll.Page(1, 20, out Rows, p => p.Num > 1500, false, "Id");
}
[TestMethod]
public void 获取数量()
{
//不带条件
var count = ubll.GetCount();
//带条件
var count1 = ubll.GetCount(p => p.Num > 5000);
}
#endregion
#region 删除
[TestMethod]
public void 删除_自定义条件()
{
ubll.Delete(p => p.Num >= 2000);
}
[TestMethod]
public void 删除_删除模型()
{
var model = ubll.FirstOrDefault();
if (model != null)
{
ubll.Delete(model);
}
}
[TestMethod]
public void 删除_根据ID删除()
{
ubll.Delete("ec45ea8b-a551-46eb-ad58-1b4f5f2aab25");
}
[TestMethod]
public void 删除_删除全部()
{
ubll.DeleteAll();
}
#endregion
#region 其他
[TestMethod]
public void 同时创建两个对象_同一数据库内()
{
LogServices Logbll = new LogServices();
UserEntity model = new UserEntity();
model.UserName = "Name" + rd.Next(100, 10000);
model.Num = rd.Next(100, 10000);
model.PostTime = DateTime.Now;
ubll.Insert(model);
LogEntity log = new LogEntity();
log.UserName1 = "Name" + rd.Next(100, 10000);
log.Num1 = rd.Next(100, 10000);
log.PostTime1 = DateTime.Now;
Logbll.Insert(log);
model.UserName = "Name" + rd.Next(100, 10000);
model.Num = rd.Next(100, 10000);
model.PostTime = DateTime.Now;
ubll.Insert(model);
}
[TestMethod]
public void 同时创建两个对象_不同一数据库内()
{
Log1Services Logbll = new Log1Services();
UserEntity model = new UserEntity();
model.UserName = "Name" + rd.Next(100, 10000);
model.Num = rd.Next(100, 10000);
model.PostTime = DateTime.Now;
ubll.Insert(model);
LogEntity log = new LogEntity();
log.UserName1 = "Name" + rd.Next(100, 10000);
log.Num1 = rd.Next(100, 10000);
log.PostTime1 = DateTime.Now;
Logbll.Insert(log);
model.UserName = "Name" + rd.Next(100, 10000);
model.Num = rd.Next(100, 10000);
model.PostTime = DateTime.Now;
ubll.Insert(model);
}
[TestMethod]
public void 当指定名称不存在时候()
{
ErrorServices error = new ErrorServices();
}
#endregion
}
以上就是自己封装的整体逻辑和代码，不过这里面还有一些不明白和不足的地方，这里提出来，希望大神们帮我解答下：
1.返回值问题
在添，删，改的使用，根据官网提供的驱动，都有一个WriteConcernResult对象返回，可是在测试中发现，这个返回的对象永远都是null
2.增加ID问题
mongodb中本身没有自增ID的属性，自带有一个ObjectID，如果我需要一个自增ID，是否是自己建一个ID属性，然后在增加的时候自己控制+1？不过这样是否性能上比较低，还要考虑多线程并发的情况下加锁的问题。所以不知道这块大家是怎么去实现的？
3.分页效率的问题
一开始分页我是先将结果转为Queryable，然后在进行操作，这个代码里面有这段，暂时注释掉了，后面再博客园上看到了一个前辈的mongodb分析后，改了下分页的方式，测试过很快，但在带条件获取记录行总数的时候，发现测试300W数据下，获取总数需要600ms的时间，不知道是我方法用错了还是有其他更好的？
最后附在几个学习的地址
mongodb入门：http://www.cnblogs.com/fish-li/archive/2011/06/26/2090800.html
官网驱动介绍：http://www.cnblogs.com/zhwl/p/3421034.html
分页优化参考：http://www.cnblogs.com/capqueen/p/MongoDBPagination.html
源码下载：戳这里-》
时间： 2024-11-13 05:22:45