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

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的增删改查。