关于Asp.Net Core MongoDB的实例代码

时间2024-01-30 08:57:02发布访客分类ASP.NET浏览743

导读：收集整理的这篇文章主要介绍了关于Asp.Net Core MongoDB的实例代码，觉得挺不错的，现在分享给大家，也给大家做个参考。废话不说直接上代码；using MongoDB.Bson.Serialization.Attributes;...

收集整理的这篇文章主要介绍了关于Asp.Net Core MongoDB的实例代码，觉得挺不错的，现在分享给大家，也给大家做个参考。废话不说直接上代码；

using MongoDB.Bson.Serialization.Attributes;
namespace XL.Core.MongoDB{
    public interface IEntITyTKey>
{
    /// summary>
    /// 主键/// /summary>
        [BsonId]        TKey Id {
     get;
     set;
 }
    }
}

View Code

    [BsonIgnoreExtraElements(Inherited = true)]public abstract class Entity : IEntitystring>
{
    /// summary>
    /// 主键/// /summary>
        [BsonRePResentation(BsonTyPE.ObjectId)]public virtual string Id {
     get;
     set;
 }
            }

View Code

    public interface IRepositoryT, in TKey>
     : IQueryableT>
     where T : IEntityTKey>
{
    #region Fileds/// summary>
    /// MongoDB表/// /summary>
    IMongoCollectionT>
 DbSet {
     get;
 }
    /// summary>
    /// MongoDB库/// /summary>
IMongoDatabase DbContext {
     get;
 }
    #endregion#region Find/// summary>
    /// 根据主键获取对象/// /summary>
    /// param name="id">
    /param>
    /// returns>
    /returns>
            T GetById(TKey id);
    /// summary>
    /// 获取对象/// /summary>
    /// param name="predicate">
    /param>
    /// returns>
    /returns>
    IEnumerableT>
     Get(ExPressionFuncT, bool>
    >
     predicate);
    /// summary>
    /// 获取对象/// /summary>
    /// param name="predicate">
    /param>
    /// param name="cancellationToken">
    /param>
    /// returns>
    /returns>
    TaskIEnumerableT>
    >
     GetAsync(ExpressionFuncT, bool>
    >
     predicate,            CancellationToken cancellationToken = default(CancellationToken));
    #endregion#region Insert/// summary>
    /// 插入文档/// /summary>
    /// param name="entity">
    /param>
    /// returns>
    /returns>
            T Insert(T entity);
    /// summary>
    /// 异步插入文档/// /summary>
    /// param name="entity">
    /param>
    /// param name="cancellationToken">
    /param>
    /// returns>
    /returns>
    Task InsertAsync(T entity, CancellationToken cancellationToken = default(CancellationToken));
    /// summary>
    ///     Adds the new entities in the repository./// /summary>
    /// param name="entities">
    The entities of type T./param>
    void Insert(IEnumerableT>
     entities);
    /// summary>
    /// 插入文档/// /summary>
    /// param name="entities">
    /param>
    /// param name="cancellationToken">
    /param>
    /// returns>
    /returns>
    Task InsertAsync(IEnumerableT>
     entities, CancellationToken cancellationToken = default(CancellationToken));
    #endregion#region Update/// summary>
    /// 更新文档/// /summary>
    /// param name="entity">
    /param>
    /// returns>
    /returns>
            UpdateResult Update(T entity);
    /// summary>
    /// 异步更新文档/// /summary>
    /// param name="entity">
    /param>
    /// param name="cancellationToken">
    /param>
    /// returns>
    /returns>
    TaskUpdateResult>
     UpdateAsync(T entity, CancellationToken cancellationToken = default(CancellationToken));
    #endregion#region Delete/// summary>
    /// 根据主键ID/// /summary>
    /// param name="id">
    /param>
    /// returns>
    /returns>
            T Delete(TKey id);
    /// summary>
    /// 异步根据ID删除文档/// /summary>
    /// param name="id">
    /param>
    /// param name="cancellationToken">
    /param>
    /// returns>
    /returns>
    TaskT>
     DeleteAsync(TKey id, CancellationToken cancellationToken = default(CancellationToken));
    /// summary>
    /// 异步删除/// /summary>
    /// param name="predicate">
    /param>
    /// param name="cancellationToken">
    /param>
    /// returns>
    /returns>
    TaskDeleteResult>
     DeleteAsync(ExpressionFuncT, bool>
    >
     predicate,            CancellationToken cancellationToken = default(CancellationToken));
    /// summary>
    /// 删除/// /summary>
    /// param name="predicate">
    /param>
    /// returns>
    /returns>
    DeleteResult Delete(ExpressionFuncT, bool>
    >
     predicate);
    #endregion#region Other/// summary>
    /// 计数/// /summary>
    /// param name="predicate">
    /param>
    /// returns>
    /returns>
    long Count(ExpressionFuncT, bool>
    >
     predicate);
    /// summary>
    /// 计数/// /summary>
    /// param name="predicate">
    /param>
    /// param name="cancellationToken">
    /param>
    /// returns>
    /returns>
    Tasklong>
     CountAsync(ExpressionFuncT, bool>
    >
     predicate,            CancellationToken cancellationToken = new CancellationToken());
    /// summary>
    /// 是否存在/// /summary>
    /// param name="predicate">
    /param>
    /// returns>
    /returns>
    bool Exists(ExpressionFuncT, bool>
    >
     predicate);
    #endregion#region Query/// summary>
    /// 分页/// 注：只适合单属性排序/// /summary>
    /// param name="predicate">
    /param>
    /// param name="sortBy">
    /param>
    /// param name="pageSize">
    /param>
    /// param name="pageindex">
    /param>
    /// returns>
    /returns>
    IEnumerableT>
     Paged(ExpressionFuncT, bool>
    >
     predicate, ExpressionFuncT, object>
    >
     sortBy,int pageSize, int pageIndex = 1);
    /// summary>
    /// /// /summary>
    /// param name="predicate">
    /param>
    /// param name="sortBy">
    /param>
    /// param name="pageSize">
    /param>
    /// param name="pageIndex">
    /param>
    /// param name="cancellationToken">
    /param>
    /// returns>
    /returns>
    TaskListT>
    >
     PagedAsync(ExpressionFuncT, bool>
    >
     predicate, ExpressionFuncT, object>
    >
     sortBy,int pageSize, int pageIndex = 1,            CancellationToken cancellationToken = new CancellationToken());
#endregion}
      public interface IRepositoryT>
     : IRepositoryT, string>
    where T : IEntitystring>
{
    }

View Code

  public class MongoRepositoryT>
     : IRepositoryT>
     where T : IEntitystring>
{
    #region Constructorprotected MongoRepository(IMongoCollectionT>
 collection)        {
                DbSet = collection;
                DbContext = collection.Database;
        }
    #endregionpublic IEnumeratorT>
 GetEnumerator()        {
    return DbSet.AsQueryable().GetEnumerator();
        }
        IEnumerator IEnumerable.GetEnumerator()        {
    return GetEnumerator();
        }
    #region 字段public Type ElementType =>
     DbSet.AsQueryable().ElementType;
    public Expression Expression =>
     DbSet.AsQueryable().Expression;
    public IQueryProvider Provider =>
     DbSet.AsQueryable().Provider;
    public IMongoCollectionT>
 DbSet {
     get;
 }
public IMongoDatabase DbContext {
     get;
 }
#endregion#region Findpublic T GetById(string id)        {
    return Get(a =>
     a.Id.Equals(id)).FirstOrDefault();
        }
    public IEnumerableT>
     Get(ExpressionFuncT, bool>
    >
 predicate)        {
    return DbSet.FindSync(predicate).current;
        }
    public async TaskIEnumerableT>
    >
     GetAsync(ExpressionFuncT, bool>
    >
 predicate,            CancellationToken cancellationToken = new CancellationToken())        {
    VAR task = await DbSet.FindAsync(predicate, null, cancellationToken);
    return task.Current;
        }
#endregion#region Insertpublic T Insert(T entity)        {
                DbSet.InsertOne(entity);
    return entity;
        }
public Task InsertAsync(T entity, CancellationToken cancellationToken = new CancellationToken())        {
    return DbSet.InsertOneAsync(entity, null, cancellationToken);
        }
    public void Insert(IEnumerableT>
 entities)        {
                DbSet.InsertMany(entities);
        }
    public Task InsertAsync(IEnumerableT>
 entities, CancellationToken cancellationToken = new CancellationToken())        {
    return DbSet.InsertManyAsync(entities, null, cancellationToken);
        }
#endregion#region Updatepublic UpdateResult Update(T entity)        {
    var doc = entity.ToBsonDocument();
    return DbSet.UpdateOne(BuildersT>
    .Filter.Eq(e =>
     e.Id, entity.Id),new BsonDocumentUpdateDefinitionT>
    (doc));
        }
    public TaskUpdateResult>
 UpdateAsync(T entity, CancellationToken cancellationToken = new CancellationToken())        {
    var doc = entity.ToBsonDocument();
    return DbSet.UpdateOneAsync(BuildersT>
    .Filter.Eq(e =>
     e.Id, entity.Id),new BsonDocumentUpdateDefinitionT>
    (doc), cancellationToken: cancellationToken);
        }
#endregion#region Deletepublic T Delete(string id)        {
    return DbSet.FindOneAndDelete(a =>
     a.Id.Equals(id));
        }
    public TaskT>
 DeleteAsync(string id, CancellationToken cancellationToken = new CancellationToken())        {
    return DbSet.FindOneAndDeleteAsync(a =>
     a.Id.Equals(id), null, cancellationToken);
        }
    public TaskDeleteResult>
     DeleteAsync(ExpressionFuncT, bool>
    >
 predicate,            CancellationToken cancellationToken = new CancellationToken())        {
    return DbSet.DeleteManyAsync(predicate, cancellationToken);
        }
    public DeleteResult Delete(ExpressionFuncT, bool>
    >
 predicate)        {
    return DbSet.DeleteMany(predicate);
        }
    #endregion#region Otherpublic long Count(ExpressionFuncT, bool>
    >
 predicate)        {
    return DbSet.Count(predicate);
        }
    public Tasklong>
     CountAsync(ExpressionFuncT, bool>
    >
 predicate,            CancellationToken cancellationToken = new CancellationToken())        {
    return DbSet.CountAsync(predicate, null, cancellationToken);
        }
    public bool Exists(ExpressionFuncT, bool>
    >
 predicate)        {
    return Get(predicate).Any();
        }
    #endregion#region Pagepublic IEnumerableT>
     Paged(ExpressionFuncT, bool>
    >
     predicate, ExpressionFuncT, object>
    >
 sortBy,int pageSize, int pageIndex = 1)        {
    var sort = BuildersT>
    .Sort.Descending(sortBy);
    return DbSet.Find(predicate).Sort(sort).Skip(pageSize * pageIndex - 1).Limit(pageSize).ToList();
        }
    public TaskListT>
    >
     PagedAsync(ExpressionFuncT, bool>
    >
     predicate, ExpressionFuncT, object>
    >
 sortBy,int pageSize, int pageIndex = 1,            CancellationToken cancellationToken = new CancellationToken())        {
    return Task.Run(() =>
{
    var sort = BuildersT>
    .Sort.Descending(sortBy);
    return DbSet.Find(predicate).Sort(sort).Skip(pageSize * pageIndex - 1).Limit(pageSize).ToList();
            }
    , cancellationToken);
        }
    #endregion#region Helper/// summary>
    /// 获取类型的所有属性信息/// /summary>
    /// typeparam name="T">
    /typeparam>
    /// typeparam name="TProperty">
    /typeparam>
    /// param name="select">
    /param>
    /// returns>
    /returns>
    private PropertyInfo[] GetPropertyInfosTProperty>
    (ExpressionFuncT, TProperty>
    >
 select)        {
    var body = select.Body;
switch (body.NodeType)            {
    case ExpressionType.Parameter:var parameterExpression = body as ParameterExpression;
    if (parameterExpression != null) return parameterExpression.Type.GetProperties();
    break;
    case ExpressionType.New:var newExpression = body as NewExpression;
    if (newExpression != null)return newExpression.Members.Select(m =>
     m as PropertyInfo).ToArray();
    break;
            }
    return null;
        }
#endregion}

View Code

使用如下：

    public class MongoDBSetting    {
public string DataBase {
     get;
     set;
 }
public string UserName {
     get;
     set;
 }
public string Password {
     get;
     set;
 }
    public ListmongoServers>
 Services {
     get;
     set;
 }
    }
public class MongoServers    {
public string Host {
     get;
     set;
 }
public int Port {
     get;
     set;
 }
     = 27017;
    }

View Code

 public class LOGsContext    {
    private readonly IMongoDatabase _db;
    public LogsContext(IOptionsMongoDBSetting>
 options)        {
    var permissionSystem =MongoCredential.CreateCredential(options.Value.DataBase, options.Value.UserName,                    options.Value.Password);
    var services = new ListMongoServerAddress>
    ();
foreach (var item in options.Value.Services)            {
                    services.Add(new MongoServerAddress(item.Host, item.Port));
            }
var settings = new MongoClientSettings            {
                Credentials = new[] {
permissionSystem}
,                Servers = services            }
    ;
    var _mongoClient = new MongoClient(settings);
                _db = _mongoClient.GetDatabase(options.Value.DataBase);
        }
    public IMongoCollectionErrorLogs>
     ErrorLog =>
     _db.GetCollectionErrorLogs>
    ("Error");
    public IMongoCollectionErrorLogs>
     WarningLog =>
     _db.GetCollectionErrorLogs>
    ("Warning");
    }

View Code

 public static IServiceCollection UserMongoLog(this IServiceCollection services,            IconfigurationSection configurationSection)        {
                services.ConfigureMongoDBSetting>
    (configurationSection);
                services.AddSingletonLogsContext>
    ();
    return services;
        }

View Code

public interface IErrorLogService : IRepositoryErrorLog>
{
    }
    public class ErrorLogService : MongoRepositoryErrorLog>
, IErrorLogService    {
public ErrorLogService(LogsContext dbContext) : base(dbContext.ErrorLog)        {
        }
    }

View Code

最后：

services.UserMongoLog(Configuration.GetSection("Mongo.Log"));

View Code

"Mongo.Log": {
"DataBase": "PermissionSystem","UserName": "sa","Password": "shtx@123","Services": [      {
"Host": "192.168.1.6","Port": "27017"  }
    ]  }

View Code

刚学洗使用MongoDB，才疏学浅，请大神多多指教

以上就是关于Asp.Net Core MongoDB的实例代码的详细内容，更多请关注其它相关文章！

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！

MongoDB

若转载请注明出处：关于Asp.Net Core MongoDB的实例代码
本文地址： https://pptw.com/jishu/592309.html

javascript怎么删除数组中指定下标的元素 javascript怎么获取隐藏元素的高度