添加dll引用
运行nuget命令：Install-Package mongocsharpdriver
即可安装MongoDb与C#相关的dll，主要有下面这4个dll。
Repository数据访问设计
1，BaseMongoDB
主要封装了连接数据库，获取数据库和获取集合的操作，如下代码。
namespace Wingon.Frameworks.MongoDb.Repository
{
/// <summary>
/// MongoDb基类
/// 主要封装了创建数据库连接，获取数据库和获取集合的操作
/// </summary>
/// <typeparam name="T"></typeparam>
public class BaseMongoDB<T> where T : class
{
public BaseMongoDB(string connectionString)
: this(connectionString, null)
{
}
public BaseMongoDB(string connectionString, string collectionName)
{
if (connectionString.IsNullOrEmpty())
{
connectionString = ConfigurationManager.ConnectionStrings["MongoTicketDB"].ConnectionString;
}
if (connectionString.IsNullOrEmpty())
{
throw new Exception("mongodb connectionString can not be empty!");
}
var mongoUrl = new MongoUrl(connectionString);
DB = GetDatabaseFromUrl(mongoUrl);
if (!string.IsNullOrEmpty(collectionName))
{
CollectionName = collectionName;
this.Collection = DB.GetCollection<T>(collectionName);
}
}
/// <summary>
/// 依据连接字符串获取数据库
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
private IMongoDatabase GetDatabaseFromUrl(MongoUrl url)
{
var client = new MongoClient(url);
var db = client.GetDatabase(url.DatabaseName);
return db;
}
/// <summary>
/// 集合
/// </summary>
public IMongoCollection<T> Collection { get; }
/// <summary>
/// 数据库
/// </summary>
public IMongoDatabase DB { get; }
/// <summary>
/// 集合名称，默认为空
/// </summary>
public string CollectionName { get; } = string.Empty;
}
}
2，MongoRepository
主要封装了对数据库的常用操作，比如增，删，改和查等，如下代码。
namespace Wingon.Frameworks.MongoDb.Repository
{
/// <summary>
/// MongoDb数据访问基类
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TKey"></typeparam>
public class MongoRepository<T, TKey> : BaseMongoDB<T> where T : class
{
private readonly Type _keyType;
protected MongoRepository(string connectionString = "", string collectionName = "")
: base(connectionString, GetCollectionName(collectionName))
{
_keyType = typeof(TKey);
if (_keyType != typeof(string) && _keyType != typeof(long) && _keyType != typeof(ObjectId))
{
throw new Exception("TKey must these type: string or long or ObjectId");
}
Initial();
}
/// <summary>
/// 初始化
/// 注册序列化器
/// </summary>
private void Initial()
{
try
{
var serializer = BsonSerializer.LookupSerializer(typeof(DateTime));
if (serializer == null || serializer.GetType() != typeof(LocalTimeSerializer))
{
// remove exist
var cacheFieldInfo = typeof(BsonSerializerRegistry).
GetField("_cache", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
var _cacheTemp = cacheFieldInfo.GetValue(BsonSerializer.SerializerRegistry);
var _cache = _cacheTemp as ConcurrentDictionary<Type, IBsonSerializer>;
IBsonSerializer removeed;
_cache.TryRemove(typeof(DateTime), out removeed);
// add my owner
BsonSerializer.RegisterSerializer(typeof(DateTime), new LocalTimeSerializer());
}
}
catch
{
}
}
/// <summary>
/// 依据连接字符串创建数据库访问实例
/// </summary>
/// <param name="db"></param>
/// <returns></returns>
public static MongoRepository<T, TKey> CreateRepository(MongoDBs db = MongoDBs.MongoTicketDB)
{
var connStrName = Enum.GetName(typeof(MongoDBs), db);
var connStr = ConfigurationManager.ConnectionStrings[connStrName].ConnectionString;
return new MongoRepository<T, TKey>(connStr);
}
/// <summary>
/// 获取集合名
/// </summary>
/// <param name="specifiedCollectionName"></param>
/// <returns></returns>
private static string GetCollectionName(string specifiedCollectionName)
{
string collectionName;
if (!specifiedCollectionName.IsNullOrEmpty())
{
collectionName = specifiedCollectionName;
}
else
{
var att = Attribute.GetCustomAttribute(typeof(T), typeof(CollectionNameAttribute));
collectionName = att != null ? ((CollectionNameAttribute)att).Name : typeof(T).Name;
if (string.IsNullOrEmpty(collectionName))
{
throw new ArgumentException("Collection name cannot be empty for this entity");
}
}
return collectionName;
}
/// <summary>
/// 判断集合是否存在
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
public bool Exists(Expression<Func<T, bool>> predicate)
{
var count = this.Collection.Find(predicate).CountAsync().Result;
return count > 0;
}
/// <summary>
/// 依据id获取实体(文档)
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public T GetById(TKey id)
{
var filter = Builders<T>.Filter.Eq("_id", id);
var result = this.Collection.Find(filter).FirstOrDefaultAsync().Result;
return result;
}
/// <summary>
/// 查询所有实体
/// </summary>
/// <returns></returns>
public IEnumerable<T> GetAll()
{
return this.Collection.Find(new BsonDocument()).ToListAsync().Result;
}
/// <summary>
/// 依据查询表达式来查询实体
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
public IEnumerable<T> GetBy(Expression<Func<T, bool>> predicate)
{
return this.Collection.Find(predicate).ToListAsync().Result;
}
/// <summary>
/// 分页查询
/// </summary>
/// <param name="predicate"></param>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <param name="orderBy"></param>
/// <returns></returns>
public IEnumerable<T> GetByPaging(Expression<Func<T, bool>> predicate, int pageIndex, int pageSize, IList<OrderBy<T>> orderBy = null)
{
if (pageIndex < 1)
{
pageIndex = 1;
}
if (pageSize < 1)
{
pageSize = 15;
}
var data = this.Collection.Find(predicate);
if (orderBy != null && orderBy.Count > 0)
{
var idx = 0;
foreach (var sort in orderBy)
{
idx++;
if (idx == 1)
{
data = sort.IsAscending ? data.SortBy(sort.Field) : data.SortByDescending(sort.Field);
}
else
{
var sortByData = data as IOrderedFindFluent<T, T>;
if (sortByData == null)
{
continue;
}
data = sort.IsAscending ? sortByData.ThenBy(sort.Field) : sortByData.ThenByDescending(sort.Field);
}
}
}
var result = data.Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync().Result;
return result;
}
/// <summary>
/// 新增(单个)
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public void Insert(T entity)
{
AsyncHelper.RunSync(() => this.Collection.InsertOneAsync(entity));
}
/// <summary>
/// 新增(批量)
/// </summary>
/// <param name="entities"></param>
/// <returns></returns>
public void Insert(IEnumerable<T> entities)
{
AsyncHelper.RunSync(() => this.Collection.InsertManyAsync(entities));
}
/// <summary>
/// 新增，从json字符串
/// </summary>
/// <param name="json"></param>
/// <returns></returns>
public IList<BsonDocument> Insert(string json)
{
if (string.IsNullOrWhiteSpace(json))
{
return new List<BsonDocument>();
}
if (typeof(T) != typeof(BsonDocument))
{
throw new Exception("this method just for MogoRepository<BsonDocument> ");
}
var documents = new List<BsonDocument>();
if (json.TrimStart().StartsWith("["))
{
var bsonDocument = BsonSerializer.Deserialize<BsonArray>(json);
foreach (var b in bsonDocument)
{
var bd = b.ToBsonDocument();
bd.Remove("$id");
documents.Add(bd);
}
}
else
{
var bsonDocument = BsonSerializer.Deserialize<BsonDocument>(json);
bsonDocument.Remove("$id");
documents.Add(bsonDocument);
}
AsyncHelper.RunSync(()=> this.DB.GetCollection<BsonDocument>(this.CollectionName).InsertManyAsync(documents));
return documents;
}
/// <summary>
/// 更新(单个)
/// </summary>
/// <param name="entity"></param>
/// <returns>返回影响的行数</returns>
public long Update(T entity)
{
var filter = Builders<T>.Filter.Eq("_id", GetIdValue(entity));
var replaceResult = this.Collection.ReplaceOneAsync(filter, entity).Result;
return replaceResult.ModifiedCount;
}
/// <summary>
/// 更新(批量)
/// </summary>
/// <param name="entities"></param>
/// <returns></returns>
public long Update(IEnumerable<T> entities)
{
long modifiedCount = 0;
foreach (var entity in entities)
{
var filter = Builders<T>.Filter.Eq("_id", GetIdValue(entity));
var replaceResult = this.Collection.ReplaceOneAsync(filter, entity).Result;
modifiedCount += replaceResult.ModifiedCount;
}
return modifiedCount;
}
/// <summary>
/// 更新，如果不存在则新增
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public bool UpdateOrAdd(T entity)
{
SaveBigDataToLog(entity);
if (Update(entity) < 1)
{
this.Collection.InsertOneAsync(entity);
}
return true;
}
/// <summary>
/// 更新(局部更新)
/// </summary>
/// <param name="query"></param>
/// <param name="columnValues">指定字段</param>
/// <returns></returns>
public long Update(Expression<Func<T, bool>> query, Dictionary<string, object> columnValues)
{
if (columnValues == null || columnValues.Count == 0)
{
throw new ArgumentException("Update Columns is Null!", nameof(columnValues));
}
var fileter = Builders<T>.Filter.Where(query);
var update = Builders<T>.Update;
UpdateDefinition<T> updateDefinination = null;
columnValues.Keys.ToList().ForEach(x =>
{
updateDefinination = updateDefinination == null ? update.Set(x, columnValues[x]) : updateDefinination.Set(x, columnValues[x]);
});
var result = this.Collection.UpdateManyAsync<T>(query, updateDefinination).Result;
return result.ModifiedCount;
}
/// <summary>
/// 依据id删除数据(文档)
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public long Delete(TKey id)
{
var filter = Builders<T>.Filter.Eq("_id", id);
var result = this.Collection.DeleteOneAsync(filter).Result;
return result.DeletedCount;
}
/// <summary>
/// 删除，依据实体
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public long Delete(T entity)
{
var filter = Builders<T>.Filter.Eq("_id", GetIdValue(entity));
var result = this.Collection.DeleteOneAsync(filter).Result;
return result.DeletedCount;
}
/// <summary>
/// 删除，依据查询表达式
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
public long Delete(Expression<Func<T, bool>> predicate)
{
var result = this.Collection.DeleteManyAsync<T>(predicate).Result;
return result.DeletedCount;
}
/// <summary>
/// 删除所有
/// </summary>
/// <returns></returns>
public void RemoveAll()
{
AsyncHelper.RunSync(()=> this.Collection.DeleteManyAsync(new BsonDocument()));
}
#region Private method
/// <summary>
/// 获取实体的id
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
private object GetIdValue(T entity)
{
object result = null;
if (typeof(T).IsSubclassOf(typeof(BaseMongoEntity<TKey>)))
{
var baseEntity = entity as BaseMongoEntity<TKey>;
result = baseEntity.Id;
}
else if (typeof(T) == typeof(BsonDocument))
{
var bson = entity as BsonDocument;
var objectId = bson["_id"];
if (objectId != null && objectId.IsObjectId)
{
result = objectId.AsObjectId;
}
}
if (result == null)
{
throw new Exception("can not get Id (or ObjectId) from the entity, please check!");
}
return result;
}
/// <summary>
/// 记录日志
/// </summary>
/// <param name="entity"></param>
private void SaveBigDataToLog(T entity)
{
try
{
var dataJson = entity.ToJson();
var saveDirector = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "VLogs", "PackageFH");
saveDirector = Path.Combine(saveDirector, "BigDataLog");
saveDirector = Path.Combine(saveDirector, DateTime.Now.ToString("yyyyMMdd"));
if (!Directory.Exists(saveDirector))
{
Directory.CreateDirectory(saveDirector);
}
var fileName = Path.Combine(saveDirector, $"{typeof(T).Name}_{Guid.NewGuid()}");
File.WriteAllText(fileName, dataJson);
}
catch
{
}
}
#endregion
}
}
Entity实体设计
因为mongoDb集合的主键主要有string，int和ObjectId(mongodb内置类型)这几种类型，所以封装了包含字段Id的泛型类型，如下代码。
namespace Wingon.Frameworks.MongoDb
{
public interface IEntity<TKey>
{
TKey Id { get; set; }
}
}
namespace Wingon.Frameworks.MongoDb
{
[DataContract(IsReference = true)]
[Serializable]
public abstract class BaseMongoEntity<TKey> : IEntity<TKey>
{
[DataMember]
public TKey Id { get; set; }
}
}
namespace Wingon.Frameworks.MongoDb.Tests.Entity
{
[DataContract(IsReference = true)]
[Serializable]
public class OrderLog: BaseMongoEntity<string>
{
[DataMember]
public int OrderId { get; set; }
[DataMember]
public decimal OrderAmount { get; set; }
[DataMember]
public string Title { get; set; }
[DataMember]
public string Summary { get; set; }
[DataMember]
[BsonDateTimeOptions(Kind = DateTimeKind.Local)]
public DateTime? UpdatedDate { get; set; }
[DataMember]
[BsonDateTimeOptions(Kind = DateTimeKind.Local)]
public DateTime OrderDate { get; set; }
}
}
需要注意的是，一般情形下，集合的主键就指定为默认的ObjectId类型，也可以手动指定为string和int类型。
时间： 2024-10-14 04:56:33