MongoDB数据仓储

本篇是作为另一篇随笔的一部分‘搭建一个Web API项目’

MogonDB官网：https://www.mongodb.org/

安装过程参考园友的分享http://www.cnblogs.com/lzrabbit/p/3682510.html

cmd client：

C:\Users\Administrator>D:
D:\> cd D:\MongoDB\Server\3.2\bin
D:\MongoDB\Server\3.2\bin>mongo 127.0.0.1:27017
>use zheyibu
>db.SEOStudent.find()

　　

一、项目Frozen.MongoObjects

     /// <summary>
     /// MongoDB支持的实体，必须要有Id
     /// </summary>
     public interface IEntity
     {
         [BsonId]
         int Id { get; set; }
     }

     /// <summary>
     ///
     /// </summary>
     public class SEOStudent : IEntity
     {
         /// <summary>
         ///
         /// </summary>
         public int Id { get; set; }

         public string Name { get; set; }

     }

二、项目Frozen.MongoCommon

（这部分的代码都是从园子里拷下来的，望大神们莫怪！本文不用于任何商业用途！）

IMongoDBRepositoryContextSettings

 using MongoDB.Driver;

 namespace Frozen.MongoCommon
 {
     /// <summary>
     /// Represents that the implemented classes are MongoDB repository context settings.
     /// </summary>
     public interface IMongoDBRepositoryContextSettings
     {
         /// <summary>
         /// Gets the database name.
         /// </summary>
         string DatabaseName { get; }
         /// <summary>
         /// Gets the instance of <see cref="MongoServerSettings"/> class which represents the
         /// settings for MongoDB server.
         /// </summary>
         MongoClientSettings ClientSettings { get; }
         /// <summary>
         /// Gets the instance of <see cref="MongoDatabaseSettings"/> class which represents the
         /// settings for MongoDB database.
         /// </summary>
         /// <param name="server">The MongoDB server instance.</param>
         /// <returns>The instance of <see cref="MongoDatabaseSettings"/> class.</returns>
         MongoDatabaseSettings GetDatabaseSettings(MongoClient client);

     }
 }

MongoDBRepositoryContextSettings

 using MongoDB.Driver;
 using System;
 using System.Configuration;

 namespace Frozen.MongoCommon
 {
     /// <summary>
     /// 表示基于MongoDB实现的仓储上下文的配置信息。
     /// </summary>
     /// <remarks>
     /// 如果您的MongoDB配置不是默认的，您可以在此处修改MongoDB的配置信息，比如
     /// 可以在ServerSettings里指定MongoDB的端口号等。
     /// </remarks>
     public class MongoDBRepositoryContextSettings : IMongoDBRepositoryContextSettings
     {
         private readonly string serverStr = "192.168.8.119";
         private readonly int port = ;
         private readonly string dbName = "zheyibu";

         public MongoDBRepositoryContextSettings()
         {
             if(ConfigurationManager.AppSettings["MongoDBServer"]!=null)
             {
                 serverStr = ConfigurationManager.AppSettings["MongoDBServer"];
             }
             if (ConfigurationManager.AppSettings["MongoDBServerPort"] != null)
             {
                 port = Int32.Parse(ConfigurationManager.AppSettings["MongoDBServerPort"]);
             }
             if (ConfigurationManager.AppSettings["MongoDBDbName"] != null)
             {
                 dbName = ConfigurationManager.AppSettings["MongoDBDbName"];
             }
         }

         #region IMongoDBRepositoryContextSettings Members
         /// <summary>
         /// 获取数据库名称。
         /// </summary>
         public string DatabaseName
         {
             get { return dbName; }
         }
         /// <summary>
         /// 获取MongoDB的服务器配置信息。
         /// </summary>
         public MongoClientSettings ClientSettings
         {
             get
             {
                 var settings = new MongoClientSettings();
                 settings.Server = new MongoServerAddress(serverStr, port);
                 settings.WriteConcern = WriteConcern.Acknowledged;
                 return settings;
             }
         }
         /// <summary>
         /// 获取数据库配置信息。
         /// </summary>
         /// <param name="server">需要配置的数据库实例。</param>
         /// <returns>数据库配置信息。</returns>
         public MongoDatabaseSettings GetDatabaseSettings(MongoClient client)
         {
             // 您无需做过多的更改：此处仅返回新建的MongoDatabaseSettings实例即可。
             return new MongoDatabaseSettings();
         }

         #endregion
     }
 }

IMongoDBRepositoryContext

 using Frozen.MongoObjects;
 using MongoDB.Driver;
 using System;

 namespace Frozen.MongoCommon
 {
     /// <summary>
     /// Mongo DB Context
     /// </summary>
     public interface IMongoDBRepositoryContext
     {
         /// <summary>
         /// Gets a <see cref="IMongoDBRepositoryContextSettings"/> instance which contains the settings
         /// information used by current context.
         /// </summary>
         IMongoDBRepositoryContextSettings Settings { get; }
         /// <summary>
         /// Gets the <see cref="MongoCollection"/> instance by the given <see cref="Type"/>.
         /// </summary>
         /// <param name="type">The <see cref="Type"/> object.</param>
         /// <returns>The <see cref="MongoCollection"/> instance.</returns>
         IMongoCollection<T> GetCollection<T>() where T : IEntity;

         /// <summary>
         /// 从MongoDB中清除所有类型为T的对象
         /// </summary>
         /// <typeparam name="T"></typeparam>
         void ClearSequence<T>();

         /// <summary>
         /// 获取类型T的对象的下一个序列
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <returns></returns>
         int getNextSequence<T>();
     }
 }

MongoDBRepositoryContext

 using MongoDB.Bson.Serialization.Conventions;
 using MongoDB.Driver;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Text;
 using System.Threading.Tasks;
 using MongoDB.Driver.Linq;
 using System.Threading;
 using Frozen.MongoObjects;

 namespace Frozen.MongoCommon
 {
     /// <summary>
     /// Represents the MongoDB repository context.
     /// </summary>
     public class MongoDBRepositoryContext : IMongoDBRepositoryContext
     {
         private readonly IMongoDBRepositoryContextSettings settings;
         private readonly MongoClient client;
         private readonly IMongoDatabase db;

         /// <summary>
         /// 构造，初始化MongoClient
         /// </summary>
         /// <param name="settings"></param>
         public MongoDBRepositoryContext(IMongoDBRepositoryContextSettings settings)
         {
             this.settings = settings;
             client = new MongoClient(settings.ClientSettings);
             db = client.GetDatabase(settings.DatabaseName);
         }

         /// <summary>
         /// Mongo 设置
         /// </summary>
         public IMongoDBRepositoryContextSettings Settings
         {
             get
             {
                 return settings;
             }
         }

         /// <summary>
         /// 获取一个集合
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <returns></returns>
         public IMongoCollection<T> GetCollection<T>() where T : IEntity
         {
             return db.GetCollection<T>(typeof(T).Name);
         }

         /// <summary>
         /// 获取Id
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <returns>序列ID</returns>
         public int getNextSequence<T>()
         {
             //此处代码需要优化，应该一个API方法就可以搞定
             var collection = db.GetCollection<Counter>("counter");

             string name = typeof(T).Name;
             var filter = Builders<Counter>.Filter.Where(t => t.id == name);
             var last = collection.Find(filter).FirstOrDefaultAsync().Result;
             if (last == null)
             {
                 collection.InsertOneAsync(new Counter() { id = name, seq =  });
             }

             var def = Builders<Counter>.Update.Inc(t => t.seq, );
             collection.FindOneAndUpdateAsync(filter, def).Wait();
             return collection.Find(filter).FirstOrDefaultAsync().Result.seq;

         }

         /// <summary>
         /// 清除序列
         /// </summary>
         /// <typeparam name="T"></typeparam>
         public void ClearSequence<T>()
         {
             var collection = db.GetCollection<Counter>("counter");

             string name = typeof(T).Name;
             var filter = Builders<Counter>.Filter.Where(t => t.id == name);
             var def = Builders<Counter>.Update.Set(t => t.seq, );
             collection.FindOneAndUpdateAsync(filter,def).Wait();
         }
     }

     /// <summary>
     /// 序列
     /// </summary>
     public class Counter
     {
         /// <summary>
         /// 类型的Id
         /// </summary>
         public string id { get; set; }

         /// <summary>
         /// 当前的序列
         /// </summary>
         public int seq { get; set; }
     }
 }

MongoDBRepository

 using System;
 using System.Collections.Generic;
 using System.Linq.Expressions;
 using MongoDB.Driver;
 using Frozen.MongoObjects;

 namespace Frozen.MongoCommon
 {
     /// <summary>
     ///     Represents the MongoDB repository.
     /// </summary>
     /// <typeparam name="T">实现了IEntity的实体类</typeparam>
     public class MongoDBRepository<T> where T : class, IEntity
     {
         #region Private Fields

         private readonly IMongoDBRepositoryContext mongoDBRepositoryContext;
         private IMongoCollection<T> collection;

         #endregion

         /// <summary>
         /// 构造
         /// </summary>
         /// <param name="context"></param>
         public MongoDBRepository(IMongoDBRepositoryContext context)
         {
             mongoDBRepositoryContext = context;
             collection = mongoDBRepositoryContext.GetCollection<T>();
         }

         /// <summary>
         /// MongoBD Context，一个集合
         /// </summary>
         protected IMongoCollection<T> DataContext
         {
             get { return collection ?? (collection = mongoDBRepositoryContext.GetCollection<T>()); }
         }

         /// <summary>
         /// 添加类型实例到Mongo
         /// </summary>
         /// <param name="entity"></param>
         public void Add(T entity)
         {
             if (entity.Id == )
             {
                 entity.Id = mongoDBRepositoryContext.getNextSequence<T>();
             }
             collection.InsertOneAsync(entity).Wait();
         }

         /// <summary>
         /// 添加集合到Mongo
         /// </summary>
         /// <param name="entities"></param>
         public void AddAll(IEnumerable<T> entities)
         {
             foreach (var it in entities)
             {
                 if (it.Id == )
                 {
                     it.Id = mongoDBRepositoryContext.getNextSequence<T>();
                 }
             }
             collection.InsertManyAsync(entities).Wait();
         }

         /// <summary>
         /// 更新实例
         /// </summary>
         /// <param name="entity"></param>
         public void Update(T entity)
         {
             var filter = Builders<T>.Filter.Where(t => t.Id == entity.Id);
             collection.ReplaceOneAsync(filter, entity).Wait();
         }

         /// <summary>
         /// 更新一组实例
         /// </summary>
         /// <param name="entities"></param>
         public void Update(IEnumerable<T> entities)
         {
             foreach (var it in entities)
             {
                 Update(it);
             }
         }

         /// <summary>
         /// 更新或添加一组实例
         /// </summary>
         /// <param name="entities"></param>
         public void UpdateOrAddAll(IEnumerable<T> entities)
         {
             var list2 = new List<T>(); //will be add
             foreach (var i in entities)
             {
                 if (GetById(i.Id) != null)
                 {
                     Update(i);
                 }
                 else
                 {
                     list2.Add(i);
                 }
             }
             if (list2.Count > )
             {
                 AddAll(list2);
             }
         }

         /// <summary>
         /// 删除实例
         /// </summary>
         /// <param name="entity"></param>
         public void Delete(T entity)
         {
             var filter = Builders<T>.Filter.Where(t => t.Id == entity.Id);
             collection.DeleteOneAsync(filter).Wait();
         }

         /// <summary>
         /// 按条件删除
         /// </summary>
         /// <param name="where"></param>
         public void Delete(Expression<Func<T, bool>> where)
         {
             collection.DeleteOneAsync(where).Wait();
         }

         /// <summary>
         /// 删除一组实例
         /// </summary>
         /// <param name="entities"></param>
         public void DeleteAll(IEnumerable<T> entities)
         {
             var filter = Builders<T>.Filter.Where(t => t.Id > );
             collection.DeleteManyAsync(filter).Wait();
         }

         /// <summary>
         /// 按Id 范围删除
         /// </summary>
         /// <param name="MinId"></param>
         /// <param name="MaxId"></param>
         public void DeleteMany(int MinId, int MaxId)
         {
             var filter = Builders<T>.Filter.Where(t => t.Id >= MinId && t.Id <= MaxId);
             collection.DeleteManyAsync(filter).Wait();
         }

         /// <summary>
         /// 清除所以
         /// </summary>
         public void Clear()
         {
             var filter = Builders<T>.Filter.Where(t => t.Id > );
             collection.DeleteManyAsync(filter).Wait();
             mongoDBRepositoryContext.ClearSequence<T>();
         }

         /// <summary>
         /// 按id查询
         /// </summary>
         /// <param name="Id"></param>
         /// <returns></returns>
         public T GetById(long Id)
         {
             return collection.Find(t => t.Id == Id).FirstOrDefaultAsync().Result;
         }

         /// <summary>
         /// 按id查询
         /// </summary>
         /// <param name="Id"></param>
         /// <returns></returns>
         public T GetById(string Id)
         {
             var entityId = ;
             int.TryParse(Id, out entityId);
             return collection.Find(t => t.Id == entityId).FirstOrDefaultAsync().Result;
         }

         /// <summary>
         /// 按条件查询
         /// </summary>
         /// <param name="where"></param>
         /// <returns></returns>
         public T Get(Expression<Func<T, bool>> where)
         {
             return collection.Find(where).FirstOrDefaultAsync().Result;
         }

         /// <summary>
         /// 获取所有
         /// </summary>
         /// <returns></returns>
         public IEnumerable<T> GetAll()
         {
             return collection.Find(t => t.Id > ).ToListAsync().Result;
         }

         /// <summary>
         /// 按条件获取
         /// </summary>
         /// <param name="where"></param>
         /// <returns></returns>
         public IEnumerable<T> GetMany(Expression<Func<T, bool>> where)
         {
             return collection.Find(where).ToListAsync().Result;
         }

         /// <summary>
         /// 获取所有
         /// </summary>
         /// <returns></returns>
         public IEnumerable<T> GetAllLazy()
         {
             return collection.Find(t => t.Id > ).ToListAsync().Result;
         }

     }
 }

三、项目Frozen.MongoRepositories

ISEOStudentMongoRepo

using Frozen.Common.Interface;
using Frozen.MongoObjects;

namespace Frozen.MongoRepositories
{
    public interface ISEOStudentMongoRepo : IRepository<SEOStudent>
    {

    }
}

SEOStudentMongoRepo

 using Frozen.MongoCommon;
 using Frozen.MongoObjects;

 namespace Frozen.MongoRepositories.Implementation
 {
     public class SEOStudentMongoRepo : MongoDBRepository<SEOStudent>, ISEOStudentMongoRepo
     {
         public SEOStudentMongoRepo(IMongoDBRepositoryContext context)
             : base(context)
         {
         }

     }
 }

其中接口IRepository的定义：

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Text;
 using System.Threading.Tasks;

 namespace Frozen.Common.Interface
 {
     public interface IRepository<T> where T : class
     {
         void Add(T entity);
         void AddAll(IEnumerable<T> entities);
         void Update(T entity);
         void Update(IEnumerable<T> entities);
         void Delete(T entity);
         void Delete(Expression<Func<T, bool>> where);
         void DeleteAll(IEnumerable<T> entities);

         void Clear();
         T GetById(long Id);
         T GetById(string Id);
         T Get(Expression<Func<T, bool>> where);
         IEnumerable<T> GetAll();
         IEnumerable<T> GetMany(Expression<Func<T, bool>> where);
         IEnumerable<T> GetAllLazy();
     }

 }

四、调用示例

             var seoStuRepo = new SEOStudentMongoRepo(new MongoDBRepositoryContext(new MongoDBRepositoryContextSettings()));

             seoStuRepo.Add(new SEOStudent() {
                 Name = "张冬林"
             });

             seoStuRepo.Add(new SEOStudent()
             {
                 Name = "张冬林"
             });

             var seoStu = seoStuRepo.Get(p => p.Name=="张冬林");

             Console.ReadKey();

五、Web API 调用示例

1、IOC注册

             #region mongoDB
             builder.RegisterType<MongoDBRepositoryContextSettings>().As<IMongoDBRepositoryContextSettings>().SingleInstance();
             builder.RegisterType<MongoDBRepositoryContext>().As<IMongoDBRepositoryContext>().SingleInstance();
             builder.RegisterAssemblyTypes(typeof(SEOStudentMongoRepo).Assembly)
                 .Where(t => t.Name.EndsWith("MongoRepo"))
                 .AsImplementedInterfaces().InstancePerLifetimeScope();
             #endregion

2、Controller调用

         private readonly ICommandBus _commandBus;
         private readonly ISEOStudentMongoRepo _seoStudentMongoRepo;

         public StudentController(ICommandBus commandBus, ISEOStudentMongoRepo seoStudentMongoRepo)
         {
             this._commandBus = commandBus;
             this._seoStudentMongoRepo = seoStudentMongoRepo;
         }

             _seoStudentMongoRepo.Add(new SEOStudent()
             {
                 Name = "张冬林"
             });

             _seoStudentMongoRepo.Add(new SEOStudent()
             {
                 Name = "张冬林"
             });

             var seoStu = _seoStudentMongoRepo.Get(p => p.Name == "张冬林");

结果截图：