近期工作中有使用到 MongoDb作为日志持久化对象，需要实现对MongoDb的增、删、改、查，但由于MongoDb的版本比较新，是2.4以上版本的，网上已有的一些MongoDb Helper类都是基于之前MongoDb旧的版本，无法适用于新版本的MongoDb，故我基于MongoDb官方C#驱动重新封装了MongoDbCsharpHelper类（CRUD类），完整代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
|
using
MongoDB;
using
MongoDB.Bson;
using
MongoDB.Driver;
using
System;
using
System.Collections;
using
System.Collections.Generic;
using
System.Linq;
using
System.Linq.Expressions;
using
System.Reflection;
using
System.Threading;
using
System.Web;
namespace
Zuowj.Utils
{
/// <summary>
/// MongoDbCsharpHelper:MongoDb基于C#语言操作帮助类
/// Author:Zuowenjun
/// Date:2017/11/16
/// </summary>
public
class
MongoDbCsharpHelper
{
private
readonly
string
connectionString =
null
;
private
readonly
string
databaseName =
null
;
private
MongoDB.Driver.IMongoDatabase database =
null
;
private
readonly
bool
autoCreateDb =
false
;
private
readonly
bool
autoCreateCollection =
false
;
static
MongoDbCsharpHelper()
{
BsonDefaults.GuidRepresentation = GuidRepresentation.Standard;
}
public
MongoDbCsharpHelper(
string
mongoConnStr,
string
dbName,
bool
autoCreateDb =
false
,
bool
autoCreateCollection =
false
)
{
this
.connectionString = mongoConnStr;
this
.databaseName = dbName;
this
.autoCreateDb = autoCreateDb;
this
.autoCreateCollection = autoCreateCollection;
}
#region 私有方法
private
MongoClient CreateMongoClient()
{
return
new
MongoClient(connectionString);
}
private
MongoDB.Driver.IMongoDatabase GetMongoDatabase()
{
if
(database ==
null
)
{
var
client = CreateMongoClient();
if
(!DatabaseExists(client, databaseName) && !autoCreateDb)
{
throw
new
KeyNotFoundException(
"此MongoDB名称不存在："
+ databaseName);
}
database = CreateMongoClient().GetDatabase(databaseName);
}
return
database;
}
private
bool
DatabaseExists(MongoClient client,
string
dbName)
{
try
{
var
dbNames = client.ListDatabases().ToList().Select(db => db.GetValue(
"name"
).AsString);
return
dbNames.Contains(dbName);
}
catch
//如果连接的账号不能枚举出所有DB会报错，则默认为true
{
return
true
;
}
}
private
bool
CollectionExists(IMongoDatabase database,
string
collectionName)
{
var
options =
new
ListCollectionsOptions
{
Filter = Builders<BsonDocument>.Filter.Eq(
"name"
, collectionName)
};
return
database.ListCollections(options).ToEnumerable().Any();
}
private
MongoDB.Driver.IMongoCollection<TDoc> GetMongoCollection<TDoc>(
string
name, MongoCollectionSettings settings =
null
)
{
var
mongoDatabase = GetMongoDatabase();
if
(!CollectionExists(mongoDatabase, name) && !autoCreateCollection)
{
throw
new
KeyNotFoundException(
"此Collection名称不存在："
+ name);
}
return
mongoDatabase.GetCollection<TDoc>(name, settings);
}
private
List<UpdateDefinition<TDoc>> BuildUpdateDefinition<TDoc>(
object
doc,
string
parent)
{
var
updateList =
new
List<UpdateDefinition<TDoc>>();
foreach
(
var
property
in
typeof
(TDoc).GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
var
key = parent ==
null
? property.Name :
string
.Format(
"{0}.{1}"
, parent, property.Name);
//非空的复杂类型
if
((property.PropertyType.IsClass || property.PropertyType.IsInterface) && property.PropertyType !=
typeof
(
string
) && property.GetValue(doc) !=
null
)
{
if
(
typeof
(IList).IsAssignableFrom(property.PropertyType))
{
#region 集合类型
int
i = 0;
var
subObj = property.GetValue(doc);
foreach
(
var
item
in
subObj
as
IList)
{
if
(item.GetType().IsClass || item.GetType().IsInterface)
{
updateList.AddRange(BuildUpdateDefinition<TDoc>(doc,
string
.Format(
"{0}.{1}"
, key, i)));
}
else
{
updateList.Add(Builders<TDoc>.Update.Set(
string
.Format(
"{0}.{1}"
, key, i), item));
}
i++;
}
#endregion
}
else
{
#region 实体类型
//复杂类型，导航属性，类对象和集合对象
var
subObj = property.GetValue(doc);
foreach
(
var
sub
in
property.PropertyType.GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
updateList.Add(Builders<TDoc>.Update.Set(
string
.Format(
"{0}.{1}"
, key, sub.Name), sub.GetValue(subObj)));
}
#endregion
}
}
else
//简单类型
{
updateList.Add(Builders<TDoc>.Update.Set(key, property.GetValue(doc)));
}
}
return
updateList;
}
private
void
CreateIndex<TDoc>(IMongoCollection<TDoc> col,
string
[] indexFields, CreateIndexOptions options =
null
)
{
if
(indexFields ==
null
)
{
return
;
}
var
indexKeys = Builders<TDoc>.IndexKeys;
IndexKeysDefinition<TDoc> keys =
null
;
if
(indexFields.Length > 0)
{
keys = indexKeys.Descending(indexFields[0]);
}
for
(
var
i = 1; i < indexFields.Length; i++)
{
var
strIndex = indexFields[i];
keys = keys.Descending(strIndex);
}
if
(keys !=
null
)
{
col.Indexes.CreateOne(keys, options);
}
}
#endregion
public
void
CreateCollectionIndex<TDoc>(
string
collectionName,
string
[] indexFields, CreateIndexOptions options =
null
)
{
CreateIndex(GetMongoCollection<TDoc>(collectionName), indexFields, options);
}
public
void
CreateCollection<TDoc>(
string
[] indexFields =
null
, CreateIndexOptions options =
null
)
{
string
collectionName =
typeof
(TDoc).Name;
CreateCollection<TDoc>(collectionName, indexFields, options);
}
public
void
CreateCollection<TDoc>(
string
collectionName,
string
[] indexFields =
null
, CreateIndexOptions options =
null
)
{
var
mongoDatabase = GetMongoDatabase();
mongoDatabase.CreateCollection(collectionName);
CreateIndex(GetMongoCollection<TDoc>(collectionName), indexFields, options);
}
public
List<TDoc> Find<TDoc>(Expression<Func<TDoc,
bool
>> filter, FindOptions options =
null
)
{
string
collectionName =
typeof
(TDoc).Name;
return
Find<TDoc>(collectionName, filter, options);
}
public
List<TDoc> Find<TDoc>(
string
collectionName, Expression<Func<TDoc,
bool
>> filter, FindOptions options =
null
)
{
var
colleciton = GetMongoCollection<TDoc>(collectionName);
return
colleciton.Find(filter, options).ToList();
}
public
List<TDoc> FindByPage<TDoc, TResult>(Expression<Func<TDoc,
bool
>> filter, Expression<Func<TDoc, TResult>> keySelector,
int
pageIndex,
int
pageSize,
out
int
rsCount)
{
string
collectionName =
typeof
(TDoc).Name;
return
FindByPage<TDoc, TResult>(collectionName, filter, keySelector, pageIndex, pageSize,
out
rsCount);
}
public
List<TDoc> FindByPage<TDoc, TResult>(
string
collectionName, Expression<Func<TDoc,
bool
>> filter, Expression<Func<TDoc, TResult>> keySelector,
int
pageIndex,
int
pageSize,
out
int
rsCount)
{
var
colleciton = GetMongoCollection<TDoc>(collectionName);
rsCount = colleciton.AsQueryable().Where(filter).Count();
int
pageCount = rsCount / pageSize + ((rsCount % pageSize) > 0 ? 1 : 0);
if
(pageIndex > pageCount) pageIndex = pageCount;
if
(pageIndex <= 0) pageIndex = 1;
return
colleciton.AsQueryable(
new
AggregateOptions { AllowDiskUse =
true
}).Where(filter).OrderByDescending(keySelector).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
}
public
void
Insert<TDoc>(TDoc doc, InsertOneOptions options =
null
)
{
string
collectionName =
typeof
(TDoc).Name;
Insert<TDoc>(collectionName, doc, options);
}
public
void
Insert<TDoc>(
string
collectionName, TDoc doc, InsertOneOptions options =
null
)
{
var
colleciton = GetMongoCollection<TDoc>(collectionName);
colleciton.InsertOne(doc, options);
}
public
void
InsertMany<TDoc>(IEnumerable<TDoc> docs, InsertManyOptions options =
null
)
{
string
collectionName =
typeof
(TDoc).Name;
InsertMany<TDoc>(collectionName, docs, options);
}
public
void
InsertMany<TDoc>(
string
collectionName, IEnumerable<TDoc> docs, InsertManyOptions options =
null
)
{
var
colleciton = GetMongoCollection<TDoc>(collectionName);
colleciton.InsertMany(docs, options);
}
public
void
Update<TDoc>(TDoc doc, Expression<Func<TDoc,
bool
>> filter, UpdateOptions options =
null
)
{
string
collectionName =
typeof
(TDoc).Name;
var
colleciton = GetMongoCollection<TDoc>(collectionName);
List<UpdateDefinition<TDoc>> updateList = BuildUpdateDefinition<TDoc>(doc,
null
);
colleciton.UpdateOne(filter, Builders<TDoc>.Update.Combine(updateList), options);
}
public
void
Update<TDoc>(
string
collectionName, TDoc doc, Expression<Func<TDoc,
bool
>> filter, UpdateOptions options =
null
)
{
var
colleciton = GetMongoCollection<TDoc>(collectionName);
List<UpdateDefinition<TDoc>> updateList = BuildUpdateDefinition<TDoc>(doc,
null
);
colleciton.UpdateOne(filter, Builders<TDoc>.Update.Combine(updateList), options);
}
public
void
Update<TDoc>(TDoc doc, Expression<Func<TDoc,
bool
>> filter, UpdateDefinition<TDoc> updateFields, UpdateOptions options =
null
)
{
string
collectionName =
typeof
(TDoc).Name;
Update<TDoc>(collectionName, doc, filter, updateFields, options);
}
public
void
Update<TDoc>(
string
collectionName, TDoc doc, Expression<Func<TDoc,
bool
>> filter, UpdateDefinition<TDoc> updateFields, UpdateOptions options =
null
)
{
var
colleciton = GetMongoCollection<TDoc>(collectionName);
colleciton.UpdateOne(filter, updateFields, options);
}
public
void
UpdateMany<TDoc>(TDoc doc, Expression<Func<TDoc,
bool
>> filter, UpdateOptions options =
null
)
{
string
collectionName =
typeof
(TDoc).Name;
UpdateMany<TDoc>(collectionName, doc, filter, options);
}
public
void
UpdateMany<TDoc>(
string
collectionName, TDoc doc, Expression<Func<TDoc,
bool
>> filter, UpdateOptions options =
null
)
{
var
colleciton = GetMongoCollection<TDoc>(collectionName);
List<UpdateDefinition<TDoc>> updateList = BuildUpdateDefinition<TDoc>(doc,
null
);
colleciton.UpdateMany(filter, Builders<TDoc>.Update.Combine(updateList), options);
}
public
void
Delete<TDoc>(Expression<Func<TDoc,
bool
>> filter, DeleteOptions options =
null
)
{
string
collectionName =
typeof
(TDoc).Name;
Delete<TDoc>(collectionName, filter, options);
}
public
void
Delete<TDoc>(
string
collectionName, Expression<Func<TDoc,
bool
>> filter, DeleteOptions options =
null
)
{
var
colleciton = GetMongoCollection<TDoc>(collectionName);
colleciton.DeleteOne(filter, options);
}
public
void
DeleteMany<TDoc>(Expression<Func<TDoc,
bool
>> filter, DeleteOptions options =
null
)
{
string
collectionName =
typeof
(TDoc).Name;
DeleteMany<TDoc>(collectionName, filter, options);
}
public
void
DeleteMany<TDoc>(
string
collectionName, Expression<Func<TDoc,
bool
>> filter, DeleteOptions options =
null
)
{
var
colleciton = GetMongoCollection<TDoc>(collectionName);
colleciton.DeleteMany(filter, options);
}
public
void
ClearCollection<TDoc>(
string
collectionName)
{
var
colleciton = GetMongoCollection<TDoc>(collectionName);
var
inddexs = colleciton.Indexes.List();
List<IEnumerable<BsonDocument>> docIndexs =
new
List<IEnumerable<BsonDocument>>();
while
(inddexs.MoveNext())
{
docIndexs.Add(inddexs.Current);
}
var
mongoDatabase = GetMongoDatabase();
mongoDatabase.DropCollection(collectionName);
if
(!CollectionExists(mongoDatabase, collectionName))
{
CreateCollection<TDoc>(collectionName);
}
if
(docIndexs.Count > 0)
{
colleciton = mongoDatabase.GetCollection<TDoc>(collectionName);
foreach
(
var
index
in
docIndexs)
{
foreach
(IndexKeysDefinition<TDoc> indexItem
in
index)
{
try
{
colleciton.Indexes.CreateOne(indexItem);
}
catch
{ }
}
}
}
}
}
}
|
对上述代码中几个特别的点进行简要说明：
1.由于MongoClient.GetDatabase 获取DB、MongoClient.GetCollection<TDoc> 获取文档（也可称为表）的方法 都有一个特点，即：如果指定的DB名称、Collection名称不存在，则会直接创建，但有的时候可能是因为DB名称、Collection名称写错了导致误创建了的DB或Collection，那就引起不必要的麻烦，故在MongoDbCsharpHelper类类内部封装了两个私有的方法：DatabaseExists（判断DB是否存在，如是连接的账号没有检索DB的权限可能会报错，故代码中加了直接返回true）、CollectionExists（判断Collection是否存在）；
2.每个CRUD方法，我都分别重载了两个方法，一个是无需指定Collection名称，一个是需要指定Collection名称，为什么这么做呢？原因很简单，因为有时Collection的结构是相同的但又是不同的Collection，这时TDoc是同一个实体类，但collectionName却是不同的；
3.分页查询的时候如果Collection的数据量比较大，那么就会报类似错误：exception: Sort exceeded memory limit of 104857600 bytes, but did not opt in to external sorting. Aborting operation. Pass allowDiskUse:true，根据报错提示，我们在查询大数据量时增加AggregateOptions对象，如： colleciton.AsQueryable(new AggregateOptions { AllowDiskUse = true })
4.ClearCollection清除Collection的所有数据，如果Collection的数据量非常大，那么直接使用colleciton.DeleteMany可能需要很久，有没有类似SQL SERVER 的truncate table的方法呢？经过多方论证，很遗憾并没有找到同类功能的方法，只有DropCollection方法，而这个DropCollection方法是直接删除Collection，当然包括Collection的所有数据，效率也非常高，但是由于是Drop，Collection就不存在了，如果再访问有可能会报Collection不存在的错误，那有没有好的办法解决了，当然有，那就是先DropCollection 然后再CreateCollection，最后别忘了把原有的索引插入到新创建的Collection中，这样就实现了truncate 初始化表的作用，当然在创建索引的时候，有的时候可能报报错（如：_id），因为_id默认就会被创建索引，再创建可能就会报错，故colleciton.Indexes.CreateOne外我加了try catch，如果报错则忽略。
5.CreateCollection（创建集合）、CreateCollectionIndex（创建集合索引）因为有的时候我们需要明确的去创建一个Collection或对已有的Collection创建索引，如果通过shell命令会非常不方便，故在此封装了一下。
使用示例如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
var
mongoDbHelper =
new
MongoDbCsharpHelper(
"MongoDbConnectionString"
,
"LogDB"
);
mongoDbHelper.CreateCollection<SysLogInfo>(
"SysLog1"
,
new
[]{
"LogDT"
});
mongoDbHelper.Find<SysLogInfo>(
"SysLog1"
, t => t.Level ==
"Info"
);
int
rsCount=0;
mongoDbHelper.FindByPage<SysLogInfo, SysLogInfo>(
"SysLog1"
,t=>t.Level==
"Info"
,t=>t,1,20,
out
rsCount);
mongoDbHelper.Insert<SysLogInfo>(
"SysLog1"
,
new
SysLogInfo { LogDT = DateTime.Now, Level =
"Info"
, Msg =
"测试消息"
});
mongoDbHelper.Update<SysLogInfo>(
"SysLog1"
,
new
SysLogInfo { LogDT = DateTime.Now, Level =
"Error"
, Msg =
"测试消息2"
},t => t.LogDT==
new
DateTime(1900,1,1));
mongoDbHelper.Delete<SysLogInfo>(t => t.Level ==
"Info"
);
mongoDbHelper.ClearCollection<SysLogInfo>(
"SysLog1"
);
|
本文转自 梦在旅途 博客园博客，原文链接： http://www.cnblogs.com/zuowj/p/8242532.html ，如需转载请自行联系原作者
