1.新建MVC项目， 管理NuGet包，进入下载MongDB.net库文件

2.新增项目DAL数据访问层，引用以下库文件：

3.C# 访问MongoDB通用方法类：

  1. using MongoDB.Driver;
  2. using System;
  3. namespace DAL
  4. {
  5. public class MongoDb
  6. {
  7. public MongoDb(string host,string timeOut)
  8. {
  9. this.CONNECT_TIME_OUT = timeOut;
  10. this.MONGO_CONN_HOST = host;
  11. }
  12. /// <summary>
  13. /// 数据库所在主机
  14. /// </summary>
  15. private readonly string MONGO_CONN_HOST;
  16. /// <summary>
  17. /// 数据库所在主机的端口
  18. /// </summary>
  19. private readonly int MONGO_CONN_PORT = 27017;
  20. /// <summary>
  21. /// 连接超时设置 秒
  22. /// </summary>
  23. private readonly string CONNECT_TIME_OUT;
  24. /// <summary>
  25. /// 数据库的名称
  26. /// </summary>
  27. private readonly string DB_NAME = "Mdemo";
  28. /// <summary>
  29. /// 得到数据库实例
  30. /// </summary>
  31. /// <returns></returns>
  32. public MongoDatabase GetDataBase()
  33. {
  34. MongoClientSettings mongoSetting = new MongoClientSettings();
  35. //设置连接超时时间
  36. mongoSetting.ConnectTimeout = new TimeSpan(int.Parse(CONNECT_TIME_OUT) * TimeSpan.TicksPerSecond);
  37. //设置数据库服务器
  38. mongoSetting.Server = new MongoServerAddress(MONGO_CONN_HOST, MONGO_CONN_PORT);
  39. //创建Mongo的客户端
  40. MongoClient client = new MongoClient(mongoSetting);
  41. //得到服务器端并且生成数据库实例
  42. return client.GetServer().GetDatabase(DB_NAME);
  43. }
  44. }
  45. }
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. namespace DAL
  6. {
  7. /// <summary>
  8. /// Mongodb数据库的字段特性  主要是设置索引之用
  9. /// </summary>
  10. [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
  11. public class MongoDbFieldAttribute : Attribute
  12. {
  13. /// <summary>
  14. /// 是否是索引
  15. /// </summary>
  16. public bool IsIndex { get; set; }
  17. /// <summary>
  18. /// 是否是唯一的  默认flase
  19. /// </summary>
  20. public bool Unique { get; set; }
  21. /// <summary>
  22. /// 是否是升序 默认true
  23. /// </summary>
  24. public bool Ascending { get; set; }
  25. public MongoDbFieldAttribute(bool _isIndex)
  26. {
  27. this.IsIndex = _isIndex;
  28. this.Unique = false;
  29. this.Ascending = true;
  30. }
  31. }
  32. }
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using MongoDB.Driver;
  5. using MongoDB.Bson;
  6. using MongoDB.Driver.Builders;
  7. using System.Reflection;
  8. namespace DAL
  9. {
  10. /// <summary>
  11. /// Mongo db的数据库帮助类
  12. /// </summary>
  13. public class MongoDbHelper
  14. {
  15. /// <summary>
  16. /// 数据库的实例
  17. /// </summary>
  18. private MongoDatabase _db;
  19. /// <summary>
  20. /// ObjectId的键
  21. /// </summary>
  22. private readonly string OBJECTID_KEY = "_id";
  23. public MongoDbHelper(string host,string timeOut)
  24. {
  25. this._db = new MongoDb(host,timeOut).GetDataBase();
  26. }
  27. public MongoDbHelper(MongoDatabase db)
  28. {
  29. this._db = db;
  30. }
  31. public T GetNextSequence<T>(IMongoQuery query, SortByDocument sortBy, UpdateDocument update, string collectionName,string indexName)
  32. {
  33. if (this._db == null)
  34. {
  35. return default(T);
  36. }
  37. try
  38. {
  39. MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);
  40. query = this.InitQuery(query);
  41. sortBy = this.InitSortBy(sortBy, OBJECTID_KEY);
  42. update = this.InitUpdateDocument(update, indexName);
  43. var ido = mc.FindAndModify(query, sortBy, update, true, false);
  44. return ido.GetModifiedDocumentAs<T>();
  45. }
  46. catch (Exception ex)
  47. {
  48. return default(T);
  49. }
  50. }
  51. #region 插入数据
  52. /// <summary>
  53. /// 将数据插入进数据库
  54. /// </summary>
  55. /// <typeparam name="T">需要插入数据的类型</typeparam>
  56. /// <param name="t">需要插入的具体实体</param>
  57. public bool Insert<T>(T t)
  58. {
  59. //集合名称
  60. string collectionName = typeof(T).Name;
  61. return Insert<T>(t, collectionName);
  62. }
  63. /// <summary>
  64. /// 将数据插入进数据库
  65. /// </summary>
  66. /// <typeparam name="T">需要插入数据库的实体类型</typeparam>
  67. /// <param name="t">需要插入数据库的具体实体</param>
  68. /// <param name="collectionName">指定插入的集合</param>
  69. public bool Insert<T>(T t, string collectionName)
  70. {
  71. if (this._db == null)
  72. {
  73. return false;
  74. }
  75. try
  76. {
  77. MongoCollection<BsonDocument> mc = this._db.GetCollection<BsonDocument>(collectionName);
  78. //将实体转换为bson文档
  79. BsonDocument bd = t.ToBsonDocument();
  80. //进行插入操作
  81. WriteConcernResult result = mc.Insert(bd);
  82. if (!string.IsNullOrEmpty(result.ErrorMessage))
  83. {
  84. return false;
  85. }
  86. return true;
  87. }
  88. catch (Exception ex)
  89. {
  90. return false;
  91. }
  92. }
  93. /// <summary>
  94. /// 批量插入数据
  95. /// </summary>
  96. /// <typeparam name="T">需要插入数据库的实体类型</typeparam>
  97. /// <param name="list">需要插入数据的列表</param>
  98. public bool Insert<T>(List<T> list)
  99. {
  100. //集合名称
  101. string collectionName = typeof(T).Name;
  102. return this.Insert<T>(list, collectionName);
  103. }
  104. /// <summary>
  105. /// 批量插入数据
  106. /// </summary>
  107. /// <typeparam name="T">需要插入数据库的实体类型</typeparam>
  108. /// <param name="list">需要插入数据的列表</param>
  109. /// <param name="collectionName">指定要插入的集合</param>
  110. public bool Insert<T>(List<T> list, string collectionName)
  111. {
  112. if (this._db == null)
  113. {
  114. return false;
  115. }
  116. try
  117. {
  118. MongoCollection<BsonDocument> mc = this._db.GetCollection<BsonDocument>(collectionName);
  119. //创建一个空间bson集合
  120. List<BsonDocument> bsonList = new List<BsonDocument>();
  121. //批量将数据转为bson格式 并且放进bson文档
  122. list.ForEach(t => bsonList.Add(t.ToBsonDocument()));
  123. //批量插入数据
  124. mc.InsertBatch(bsonList);
  125. return true;
  126. }
  127. catch (Exception ex)
  128. {
  129. return false;
  130. }
  131. }
  132. #endregion
  133. #region 查询数据
  134. #region 查询所有记录
  135. /// <summary>
  136. /// 查询一个集合中的所有数据
  137. /// </summary>
  138. /// <typeparam name="T">该集合数据的所属类型</typeparam>
  139. /// <param name="collectionName">指定集合的名称</param>
  140. /// <returns>返回一个List列表</returns>
  141. public List<T> FindAll<T>(string collectionName)
  142. {
  143. if (this._db == null)
  144. {
  145. return null;
  146. }
  147. try
  148. {
  149. MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);
  150. //以实体方式取出其数据集合
  151. MongoCursor<T> mongoCursor = mc.FindAll();
  152. //直接转化为List返回
  153. return mongoCursor.ToList<T>();
  154. }
  155. catch (Exception ex)
  156. {
  157. return null;
  158. }
  159. }
  160. /// <summary>
  161. /// 查询一个集合中的所有数据 其集合的名称为T的名称
  162. /// </summary>
  163. /// <typeparam name="T">该集合数据的所属类型</typeparam>
  164. /// <returns>返回一个List列表</returns>
  165. public List<T> FindAll<T>()
  166. {
  167. string collectionName = typeof(T).Name;
  168. return FindAll<T>(collectionName);
  169. }
  170. #endregion
  171. #region 查询一条记录
  172. /// <summary>
  173. /// 查询索引最大的一条记录
  174. /// </summary>
  175. /// <typeparam name="T">该数据所属的类型</typeparam>
  176. /// <param name="collectionName">去指定查询的集合</param>
  177. /// <param name="sort">排序字段</param>
  178. /// <returns>返回一个实体类型</returns>
  179. public T FindOneToIndexMax<T>(string collectionName, string[] sort)
  180. {
  181. return FindOneToIndexMax<T>(null, collectionName, sort);
  182. }
  183. /// <summary>
  184. /// 查询索引最大的一条记录
  185. /// </summary>
  186. /// <typeparam name="T">该数据所属的类型</typeparam>
  187. /// <param name="query">查询的条件 可以为空</param>
  188. /// <param name="collectionName">去指定查询的集合</param>
  189. /// <param name="sort">排序字段</param>
  190. /// <returns>返回一个实体类型</returns>
  191. public T FindOneToIndexMax<T>(IMongoQuery query,string collectionName, string[] sort)
  192. {
  193. if (this._db == null)
  194. {
  195. return default(T);
  196. }
  197. try
  198. {
  199. MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);
  200. query = this.InitQuery(query);
  201. T t = mc.Find(query).SetSortOrder(SortBy.Descending(sort)).FirstOrDefault<T>();
  202. return t;
  203. }
  204. catch (Exception ex)
  205. {
  206. return default(T);
  207. }
  208. }
  209. /// <summary>
  210. /// 查询一条记录
  211. /// </summary>
  212. /// <typeparam name="T">该数据所属的类型</typeparam>
  213. /// <param name="query">查询的条件 可以为空</param>
  214. /// <param name="collectionName">去指定查询的集合</param>
  215. /// <returns>返回一个实体类型</returns>
  216. public T FindOne<T>(IMongoQuery query, string collectionName)
  217. {
  218. if (this._db == null)
  219. {
  220. return default(T);
  221. }
  222. try
  223. {
  224. MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);
  225. query = this.InitQuery(query);
  226. T t = mc.FindOne(query);
  227. return t;
  228. }
  229. catch (Exception ex)
  230. {
  231. return default(T);
  232. }
  233. }
  234. /// <summary>
  235. /// 查询一条记录
  236. /// </summary>
  237. /// <typeparam name="T">该数据所属的类型</typeparam>
  238. /// <param name="collectionName">去指定查询的集合</param>
  239. /// <returns>返回一个实体类型</returns>
  240. public T FindOne<T>(string collectionName)
  241. {
  242. return FindOne<T>(null, collectionName);
  243. }
  244. /// <summary>
  245. /// 查询一条记录
  246. /// </summary>
  247. /// <typeparam name="T">该数据所属的类型</typeparam>
  248. /// <returns>返回一个实体类型</returns>
  249. public T FindOne<T>()
  250. {
  251. string collectionName = typeof(T).Name;
  252. return FindOne<T>(null, collectionName);
  253. }
  254. /// <summary>
  255. /// 查询一条记录
  256. /// </summary>
  257. /// <typeparam name="T">该数据所属的类型</typeparam>
  258. /// <param name="query">查询的条件 可以为空</param>
  259. /// <returns>返回一个实体类型</returns>
  260. public T FindOne<T>(IMongoQuery query)
  261. {
  262. string collectionName = typeof(T).Name;
  263. return FindOne<T>(query, collectionName);
  264. }
  265. #endregion
  266. #region 普通的条件查询
  267. /// <summary>
  268. /// 根据指定条件查询集合中的数据
  269. /// </summary>
  270. /// <typeparam name="T">该集合数据的所属类型</typeparam>
  271. /// <param name="query">指定的查询条件 比如Query.And(Query.EQ("username","admin"),Query.EQ("password":"admin"))</param>
  272. /// <param name="collectionName">指定的集合的名称</param>
  273. /// <returns>返回一个List列表</returns>
  274. public List<T> Find<T>(IMongoQuery query, string collectionName)
  275. {
  276. if (this._db == null)
  277. {
  278. return null;
  279. }
  280. try
  281. {
  282. MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);
  283. query = this.InitQuery(query);
  284. MongoCursor<T> mongoCursor = mc.Find(query);
  285. return mongoCursor.ToList<T>();
  286. }
  287. catch (Exception ex)
  288. {
  289. return null;
  290. }
  291. }
  292. /// <summary>
  293. /// 根据指定条件查询集合中的数据
  294. /// </summary>
  295. /// <typeparam name="T">该集合数据的所属类型</typeparam>
  296. /// <param name="query">指定的查询条件 比如Query.And(Query.EQ("username","admin"),Query.EQ("password":"admin"))</param>
  297. /// <returns>返回一个List列表</returns>
  298. public List<T> Find<T>(IMongoQuery query)
  299. {
  300. string collectionName = typeof(T).Name;
  301. return this.Find<T>(query,collectionName);
  302. }
  303. #endregion
  304. #region 分页查询 PageIndex和PageSize模式  在页数PageIndex大的情况下 效率明显变低
  305. /// <summary>
  306. /// 分页查询 PageIndex和PageSize模式  在页数PageIndex大的情况下 效率明显变低
  307. /// </summary>
  308. /// <typeparam name="T">所需查询的数据的实体类型</typeparam>
  309. /// <param name="query">查询的条件</param>
  310. /// <param name="pageIndex">当前的页数</param>
  311. /// <param name="pageSize">当前的尺寸</param>
  312. /// <param name="sortBy">排序方式</param>
  313. /// <param name="collectionName">集合名称</param>
  314. /// <returns>返回List列表</returns>
  315. public List<T> Find<T>(IMongoQuery query, int pageIndex, int pageSize, SortByDocument sortBy, string collectionName)
  316. {
  317. if (this._db == null)
  318. {
  319. return null;
  320. }
  321. try
  322. {
  323. MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);
  324. MongoCursor<T> mongoCursor = null;
  325. query = this.InitQuery(query);
  326. sortBy = this.InitSortBy(sortBy, OBJECTID_KEY);
  327. //如页序号为0时初始化为1
  328. pageIndex = pageIndex == 0 ? 1 : pageIndex;
  329. //按条件查询 排序 跳数 取数
  330. mongoCursor = mc.Find(query).SetSortOrder(sortBy).SetSkip((pageIndex - 1) * pageSize).SetLimit(pageSize);
  331. return mongoCursor.ToList<T>();
  332. }
  333. catch (Exception ex)
  334. {
  335. return null;
  336. }
  337. }
  338. /// <summary>
  339. /// 分页查询 PageIndex和PageSize模式  在页数PageIndex大的情况下 效率明显变低
  340. /// </summary>
  341. /// <typeparam name="T">所需查询的数据的实体类型</typeparam>
  342. /// <param name="query">查询的条件</param>
  343. /// <param name="pageIndex">当前的页数</param>
  344. /// <param name="pageSize">当前的尺寸</param>
  345. /// <param name="sortBy">排序方式</param>
  346. /// <returns>返回List列表</returns>
  347. public List<T> Find<T>(IMongoQuery query, int pageIndex, int pageSize, SortByDocument sortBy)
  348. {
  349. string collectionName = typeof(T).Name;
  350. return this.Find<T>(query, pageIndex, pageSize, sortBy, collectionName);
  351. }
  352. #endregion
  353. #region 分页查询 指定索引最后项-PageSize模式
  354. /// <summary>
  355. /// 分页查询 指定索引最后项-PageSize模式
  356. /// </summary>
  357. /// <typeparam name="T">所需查询的数据的实体类型</typeparam>
  358. /// <param name="query">查询的条件 没有可以为null</param>
  359. /// <param name="indexName">索引名称</param>
  360. /// <param name="lastKeyValue">最后索引的值</param>
  361. /// <param name="pageSize">分页的尺寸</param>
  362. /// <param name="sortType">排序类型 1升序 -1降序 仅仅针对该索引</param>
  363. /// <param name="collectionName">指定的集合名称</param>
  364. /// <returns>返回一个List列表数据</returns>
  365. public List<T> Find<T>(IMongoQuery query, string indexName, object lastKeyValue, int pageSize, int sortType, string collectionName)
  366. {
  367. if (this._db == null)
  368. {
  369. return null;
  370. }
  371. try
  372. {
  373. MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);
  374. MongoCursor<T> mongoCursor = null;
  375. query = this.InitQuery(query);
  376. //判断升降序后进行查询
  377. if (sortType > 0)
  378. {
  379. //升序
  380. if (lastKeyValue != null)
  381. {
  382. //有上一个主键的值传进来时才添加上一个主键的值的条件
  383. query = Query.And(query, Query.GT(indexName, BsonValue.Create(lastKeyValue)));
  384. }
  385. //先按条件查询 再排序 再取数
  386. mongoCursor = mc.Find(query).SetSortOrder(new SortByDocument(indexName, 1)).SetLimit(pageSize);
  387. }
  388. else
  389. {
  390. //降序
  391. if (lastKeyValue != null)
  392. {
  393. query = Query.And(query, Query.LT(indexName, BsonValue.Create(lastKeyValue)));
  394. }
  395. mongoCursor = mc.Find(query).SetSortOrder(new SortByDocument(indexName, -1)).SetLimit(pageSize);
  396. }
  397. return mongoCursor.ToList<T>();
  398. }
  399. catch (Exception ex)
  400. {
  401. return null;
  402. }
  403. }
  404. /// <summary>
  405. /// 分页查询 指定索引最后项-PageSize模式
  406. /// </summary>
  407. /// <typeparam name="T">所需查询的数据的实体类型</typeparam>
  408. /// <param name="query">查询的条件 没有可以为null</param>
  409. /// <param name="indexName">索引名称</param>
  410. /// <param name="lastKeyValue">最后索引的值</param>
  411. /// <param name="pageSize">分页的尺寸</param>
  412. /// <param name="sortType">排序类型 1升序 -1降序 仅仅针对该索引</param>
  413. /// <returns>返回一个List列表数据</returns>
  414. public List<T> Find<T>(IMongoQuery query, string indexName, object lastKeyValue, int pageSize, int sortType)
  415. {
  416. string collectionName = typeof(T).Name;
  417. return this.Find<T>(query, indexName, lastKeyValue, pageSize, sortType, collectionName);
  418. }
  419. /// <summary>
  420. /// 分页查询 指定ObjectId最后项-PageSize模式
  421. /// </summary>
  422. /// <typeparam name="T">所需查询的数据的实体类型</typeparam>
  423. /// <param name="query">查询的条件 没有可以为null</param>
  424. /// <param name="lastObjectId">上一条记录的ObjectId 没有可以为空</param>
  425. /// <param name="pageSize">每页尺寸</param>
  426. /// <param name="sortType">排序类型 1升序 -1降序 仅仅针对_id</param>
  427. /// <param name="collectionName">指定去查询集合的名称</param>
  428. /// <returns>返回一个List列表数据</returns>
  429. public List<T> Find<T>(IMongoQuery query, string lastObjectId, int pageSize, int sortType, string collectionName)
  430. {
  431. return this.Find<T>(query, OBJECTID_KEY, new ObjectId(lastObjectId), pageSize, sortType, collectionName);
  432. }
  433. /// <summary>
  434. /// 分页查询 指定ObjectId最后项-PageSize模式
  435. /// </summary>
  436. /// <typeparam name="T">所需查询的数据的实体类型</typeparam>
  437. /// <param name="query">查询的条件 没有可以为null</param>
  438. /// <param name="lastObjectId">上一条记录的ObjectId 没有可以为空</param>
  439. /// <param name="pageSize">每页尺寸</param>
  440. /// <param name="sortType">排序类型 1升序 -1降序 仅仅针对_id</param>
  441. /// <returns>返回一个List列表数据</returns>
  442. public List<T> Find<T>(IMongoQuery query, string lastObjectId, int pageSize, int sortType)
  443. {
  444. string collectionName = typeof(T).Name;
  445. return Find<T>(query, lastObjectId, pageSize, sortType, collectionName);
  446. }
  447. #endregion
  448. #endregion
  449. #region 更新数据
  450. /// <summary>
  451. /// 更新数据
  452. /// </summary>
  453. /// <typeparam name="T">更新的数据 所属的类型</typeparam>
  454. /// <param name="query">更新数据的查询</param>
  455. /// <param name="update">需要更新的文档</param>
  456. /// <param name="collectionName">指定更新集合的名称</param>
  457. public bool Update<T>(IMongoQuery query, IMongoUpdate update, string collectionName)
  458. {
  459. if (this._db == null)
  460. {
  461. return false;
  462. }
  463. try
  464. {
  465. MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);
  466. query = this.InitQuery(query);
  467. //更新数据
  468. WriteConcernResult result = mc.Update(query, update, UpdateFlags.Multi);
  469. return true;
  470. }
  471. catch (Exception ex)
  472. {
  473. return false;
  474. }
  475. }
  476. /// <summary>
  477. /// 更新数据
  478. /// </summary>
  479. /// <typeparam name="T">更新的数据 所属的类型</typeparam>
  480. /// <param name="query">更新数据的查询</param>
  481. /// <param name="update">需要更新的文档</param>
  482. public bool Update<T>(IMongoQuery query, IMongoUpdate update)
  483. {
  484. string collectionName = typeof(T).Name;
  485. return this.Update<T>(query, update, collectionName);
  486. }
  487. #endregion
  488. #region 移除/删除数据
  489. /// <summary>
  490. /// 移除指定的数据
  491. /// </summary>
  492. /// <typeparam name="T">移除的数据类型</typeparam>
  493. /// <param name="query">移除的数据条件</param>
  494. /// <param name="collectionName">指定的集合名词</param>
  495. public bool Remove<T>(IMongoQuery query, string collectionName)
  496. {
  497. if (this._db == null)
  498. {
  499. return false;
  500. }
  501. try
  502. {
  503. MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);
  504. query = this.InitQuery(query);
  505. //根据指定查询移除数据
  506. mc.Remove(query);
  507. return true;
  508. }
  509. catch (Exception ex)
  510. {
  511. return false;
  512. }
  513. }
  514. /// <summary>
  515. /// 移除指定的数据
  516. /// </summary>
  517. /// <typeparam name="T">移除的数据类型</typeparam>
  518. /// <param name="query">移除的数据条件</param>
  519. public bool Remove<T>(IMongoQuery query)
  520. {
  521. string collectionName = typeof(T).Name;
  522. return this.Remove<T>(query,collectionName);
  523. }
  524. /// <summary>
  525. /// 移除实体里面所有的数据
  526. /// </summary>
  527. /// <typeparam name="T">移除的数据类型</typeparam>
  528. public bool ReomveAll<T>()
  529. {
  530. string collectionName = typeof(T).Name;
  531. return this.Remove<T>(null,collectionName);
  532. }
  533. /// <summary>
  534. /// 移除实体里面所有的数据
  535. /// </summary>
  536. /// <typeparam name="T">移除的数据类型</typeparam>
  537. /// <param name="collectionName">指定的集合名称</param>
  538. public bool RemoveAll<T>(string collectionName)
  539. {
  540. return this.Remove<T>(null,collectionName);
  541. }
  542. #endregion
  543. #region 创建索引
  544. /// <summary>
  545. /// 创建索引
  546. /// </summary>
  547. /// <typeparam name="T">需要创建索引的实体类型</typeparam>
  548. public bool CreateIndex<T>()
  549. {
  550. if (this._db == null)
  551. {
  552. return false;
  553. }
  554. try
  555. {
  556. string collectionName = typeof(T).Name;
  557. MongoCollection<BsonDocument> mc = this._db.GetCollection<BsonDocument>(collectionName);
  558. PropertyInfo[] propertys = typeof(T).GetProperties(BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetProperty);
  559. //得到该实体类型的属性
  560. foreach (PropertyInfo property in propertys)
  561. {
  562. //在各个属性中得到其特性
  563. foreach (object obj in property.GetCustomAttributes(true))
  564. {
  565. MongoDbFieldAttribute mongoField = obj as MongoDbFieldAttribute;
  566. if (mongoField != null)
  567. {// 此特性为mongodb的字段属性
  568. IndexKeysBuilder indexKey;
  569. if (mongoField.Ascending)
  570. {
  571. //升序 索引
  572. indexKey = IndexKeys.Ascending(property.Name);
  573. }
  574. else
  575. {
  576. //降序索引
  577. indexKey = IndexKeys.Descending(property.Name);
  578. }
  579. //创建该属性
  580. mc.CreateIndex(indexKey, IndexOptions.SetUnique(mongoField.Unique));
  581. }
  582. }
  583. }
  584. return true;
  585. }
  586. catch (Exception ex)
  587. {
  588. return false;
  589. }
  590. }
  591. #endregion
  592. #region 获取表的行数
  593. /// <summary>
  594. /// 获取数据表总行数
  595. /// </summary>
  596. /// <typeparam name="T"></typeparam>
  597. /// <param name="query"></param>
  598. /// <param name="collectionName"></param>
  599. /// <returns></returns>
  600. public long GetCount<T>(IMongoQuery query,string collectionName)
  601. {
  602. if (this._db == null)
  603. {
  604. return 0;
  605. }
  606. try
  607. {
  608. MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);
  609. if (query == null)
  610. {
  611. return mc.Count();
  612. }
  613. else
  614. {
  615. return mc.Count(query);
  616. }
  617. }
  618. catch (Exception ex)
  619. {
  620. return 0;
  621. }
  622. }
  623. /// <summary>
  624. /// 获取数据表总行数
  625. /// </summary>
  626. /// <typeparam name="T"></typeparam>
  627. /// <param name="query"></param>
  628. /// <returns></returns>
  629. public long GetCount<T>(IMongoQuery query)
  630. {
  631. string collectionName = typeof(T).Name;
  632. return GetCount<T>(query,collectionName);
  633. }
  634. #endregion
  635. #region 获取集合的存储大小
  636. /// <summary>
  637. /// 获取集合的存储大小
  638. /// </summary>
  639. /// <typeparam name="T">该集合对应的实体类</typeparam>
  640. /// <returns>返回一个long型</returns>
  641. public long GetDataSize<T>()
  642. {
  643. string collectionName = typeof(T).Name;
  644. return GetDataSize(collectionName);
  645. }
  646. /// <summary>
  647. /// 获取集合的存储大小
  648. /// </summary>
  649. /// <param name="collectionName">该集合对应的名称</param>
  650. /// <returns>返回一个long型</returns>
  651. public long GetDataSize(string collectionName)
  652. {
  653. if (this._db == null)
  654. {
  655. return 0;
  656. }
  657. try
  658. {
  659. MongoCollection<BsonDocument> mc = this._db.GetCollection<BsonDocument>(collectionName);
  660. return mc.GetTotalStorageSize();
  661. }
  662. catch (Exception ex)
  663. {
  664. return 0;
  665. }
  666. }
  667. #endregion
  668. #region 私有的一些辅助方法
  669. /// <summary>
  670. /// 初始化查询记录 主要当该查询条件为空时 会附加一个恒真的查询条件，防止空查询报错
  671. /// </summary>
  672. /// <param name="query">查询的条件</param>
  673. /// <returns></returns>
  674. private IMongoQuery InitQuery(IMongoQuery query)
  675. {
  676. if (query == null)
  677. {
  678. //当查询为空时 附加恒真的条件 类似SQL：1=1的语法
  679. query = Query.Exists(OBJECTID_KEY);
  680. }
  681. return query;
  682. }
  683. /// <summary>
  684. /// 初始化排序条件  主要当条件为空时 会默认以ObjectId递增的一个排序
  685. /// </summary>
  686. /// <param name="sortBy"></param>
  687. /// <param name="sortByName"></param>
  688. /// <returns></returns>
  689. private SortByDocument InitSortBy(SortByDocument sortBy, string sortByName)
  690. {
  691. if (sortBy == null)
  692. {
  693. //默认ObjectId 递增
  694. sortBy = new SortByDocument(sortByName, -1);
  695. }
  696. return sortBy;
  697. }
  698. private UpdateDocument InitUpdateDocument(UpdateDocument update,string indexName)
  699. {
  700. if (update == null)
  701. {
  702. update = new UpdateDocument("$inc", new QueryDocument(indexName, 0));
  703. }
  704. return update;
  705. }
  706. #endregion
  707. }
  708. }

4.调用：先引用库文件：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Web;
  5. using System.Web.Mvc;
  6. using MongoDB;
  7. using MongoDbDemo;
  8. using MongoDB.Driver;
  9. using MongoDB.Bson;
  10. using DAL.Entity;
  11. using DAL;
  12. using MongoDB.Driver.Builders;
  13. using System.Diagnostics;
  14. namespace MongoDbDemo.Controllers
  15. {
  16. public class HomeController : Controller
  17. {
  18. //
  19. // GET: /Home/
  20. public ActionResult Index()
  21. {
  22. return Content("MongoDbDemo");
  23. }
  24. #region INSERT
  25. /// <summary>
  26. /// 添加用户
  27. /// </summary>
  28. /// <returns></returns>
  29. public ActionResult Ruser()
  30. {
  31. try
  32. {
  33. string name = Request["name"];
  34. string age = Request["age"];
  35. User user1 = new User { Uname = name, Age = age };
  36. MongoDbHelper mh = new MongoDbHelper("127.0.0.1", "1000");
  37. if (mh.Insert<User>(user1))
  38. {
  39. return Json(new { success = "true" });
  40. }
  41. }
  42. catch (Exception)
  43. {
  44. return Json(new { success = "filled" });
  45. throw;
  46. }
  47. return Json(new { success = "filled" });
  48. }
  49. #endregion
  50. #region SELECT
  51. /// <summary>
  52. /// 查询一个集合中的所有数据
  53. /// </summary>
  54. /// <returns></returns>
  55. public ActionResult Seluser()
  56. {
  57. MongoDbHelper mh = new MongoDbHelper("127.0.0.1", "1000");
  58. List<User> users = mh.FindAll<User>();
  59. return Json(new { success="true"});
  60. }
  61. /// <summary>
  62. /// 按条件查询一条数据
  63. /// </summary>
  64. /// <returns></returns>
  65. public ActionResult SelOne()
  66. {
  67. string name = Request["name"];
  68. string age=Request["age"];
  69. MongoDbHelper mh = new MongoDbHelper("127.0.0.1", "1000");
  70. User users = mh.FindOne<User>(Query.And(Query.EQ("Uname", name), Query.EQ("Age", age)));
  71. return Json(new {success="true" ,users=users});
  72. }
  73. /// <summary>
  74. /// 分页查询
  75. /// </summary>
  76. /// <returns></returns>
  77. public ActionResult SelPage()
  78. {
  79. int pageindex=int.Parse(Request["pageindex"]);//页索引
  80. int pagesize = int.Parse(Request["pagesize"]);//行数
  81. MongoDbHelper mh = new MongoDbHelper("127.0.0.1", "1000");
  82. Stopwatch sw1 = new Stopwatch();
  83. sw1.Start();
  84. List<User> users = mh.Find<User>(null,pageindex,pagesize,null);
  85. return Json(new {success="true",users=users });
  86. }
  87. #endregion
  88. #region UPDATE
  89. /// <summary>
  90. /// 修改信息
  91. /// </summary>
  92. /// <returns></returns>
  93. public ActionResult upduser()
  94. {
  95. MongoDbHelper mh = new MongoDbHelper("127.0.0.1", "1000");
  96. if (mh.Update<User>(Query.EQ("Uname", "阿斯达"), Update.Set("Uname", "阿斯达s"), "User"))
  97. {
  98. return Json(new { success = "true" });
  99. }
  100. else
  101. {
  102. return Json(new { success = "fales" });
  103. }
  104. }
  105. #endregion
  106. #region DELETE
  107. /// <summary>
  108. /// 删除消息
  109. /// </summary>
  110. /// <returns></returns>
  111. public ActionResult deluser()
  112. {
  113. MongoDbHelper mh = new MongoDbHelper("127.0.0.1", "1000");
  114. if (mh.Remove<User>(Query.EQ("Uname", "阿斯达s")))
  115. {
  116. return Json(new { success = "true" });
  117. }
  118. else {
  119. return Json(new { success = "fales" });
  120. }
  121. }
  122. #endregion
  123. }
  124. }

简单的使用.NET 进行MongoDB的增删改查。

【MongoDB学习-在.NET中的简单操作】的更多相关文章

  1. MongoDB学习-在.NET中的简单操作

    1.新建MVC项目, 管理NuGet包,进入下载MongDB.net库文件 2.新增项目DAL数据访问层,引用以下库文件: 3.C# 访问MongoDB通用方法类: using MongoDB.Dri ...

  2. 【MongoDB学习-在.NET中的简单操作类】

    1.新建MVC项目, 管理NuGet包,进入下载MongDB.net库文件 2.新增项目DAL数据访问层,引用以下库文件: 3.C# 访问MongoDB通用方法类: using MongoDB.Dri ...

  3. C# 对MongoDB 进行增删改查的简单操作

    C# 对MongoDB 进行增删改查的简单操作   下面演示下C#操作MongoDB驱动的简单的增删改查代码 运用到的MongoDB支持的C#驱动,当前版本为1.6.0 1,连接数据库   /// & ...

  4. 使用Flask+MongoDB实现基于REST的接口简单操作

    目录 前言 1 准备工作 2 具体实现 前言 最近在捣鼓如何使用阿里云服务器搭建一个简单的基于Flask框架的后端接口,刚开始为了图方便,就直接买了一个Windows Server 2008系统服务器 ...

  5. MongoDB学习(1)--安装，基本curd操作

    知识点: 1-MongoDB 安装,启动和卸载 2-基本概念 3-基本的增删改查操作(CURD) 来回顾总结一把学习的mongodb,如果有javascript基础,学习"芒果DB" ...

  6. iOS学习之UITableView中Cell的操作

    接着iOS学习之Table View的简单使用 这篇,这里主要讲UITableView 中的Cell的操作,包括标记.移动.删除.插入. 为了简单快捷,直接从原来那篇的代码开始,代码下载地址:http ...

  7. Python学习笔记3-文件的简单操作

    Python中的文件操作 Python中文件打操作离不开两个模块  os 和 shutil os:操作文件.目录: Python os模块包含普遍的操作系统功能.如果你希望你的程序能够与平台无关的话, ...

  8. JavaWeb学习笔记——jquery中的dom操作

     jquery中的dom操作 废话不说:直接上例子: 1.添加节点-html页面 Append:向每个匹配的元素内部追加内容. <body> <ul id="city& ...

  9. Python框架学习之Flask中的数据库操作

    数据库操作在web开发中扮演着一个很重要的角色,网站中很多重要的信息都需要保存到数据库中.如用户名.密码等等其他信息.Django框架是一个基于MVT思想的框架,也就是说他本身就已经封装了Model类 ...

随机推荐

  1. this与$(this)对象

    this与$(this)对象.前者是Javascript对象,而后者是jQuery是对象.两者分清楚,它们只能使用自己的方法.Javascript对象使用Javascript的方法,jQuery对象使 ...

  2. AEAI Portal 权限体系说明

    1.概述 在数通畅联的产品体系中,AEAI Portal毫无疑问的占据了很重要的地位,在这里我们将通过参考Portal样例,讲述一下AEAI Portal权限体系的控制方法.在Portal使用过程中, ...

  3. css伪元素:before和:after用法详解

    css的伪元素,之所以被称为伪元素,是因为他们不是真正的页面元素,html没有对应的元素,但是其所有用法和表现行为与真正的页面元素一样,可以对其使用诸如页面元素一样的css样式,表面上看上去貌似是页面 ...

  4. 【HDU5730】 Shell Necklace

    HDU5730 Shell Necklace 题目大意 已知连续i(1<=i<=n)个贝壳组合成一段项链的方案数a[i],求组合成包含n个贝壳的项链的总方案数. Solution cdq分 ...

  5. Python 常用的内置函数

    1. str.isdigit( ) 作用:检测字符串是否有数字组成 2. strip( ) 作用:除去首尾指定的字符,包括空格,换行符,不能除去中间的字符 3. slice( ) 作用:以指定参数切割 ...

  6. Linux巩固记录（6） Hbase环境准备-zookeeper安装

    Hbase是运行在hadoop之上,所以请参考第3篇文章搭建好一个master,两个slave的hadoop环境,我采用的版本为hadoop2.7.4 不了解Hbase的同学可以参考下这篇文章,分析得 ...

  7. poi 读取使用 Strict Open XML 保存的 excel 文档

    poi 读取使用 Strict Open XML 保存的 excel 文档 某项目有一个功能需要读取 excel 报表内容,使用poi读取时报错: 具体错误为: org.apache.poi.POIX ...

  8. CentOS7安装MYSQL。

    参考这个文章(网页已存到本地):http://www.cnblogs.com/starof/p/4680083.html 安装完成后,本地登录MYSQL没有问题. 现在主要是在windows下用ora ...

  9. java项目配置域名（tomcat直接配置 or 使用nginx反向代理）

    一:  tomcat直接配置域名:https://blog.csdn.net/qq_36330228/article/details/78516160 二: 使用nginx进行反向代理 tomcat服 ...

  10. Java调用HTTPS接口的证书配置

    首先需要获取到证书文件. 然后,将证书导入到本地: keytool -import -noprompt -trustcacerts -alias <AliasName> -file < ...