MongoDB数据仓储

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

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

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

cmd client：

C:UsersAdministrator>D:
D:> cd D:MongoDBServer3.2in
D:MongoDBServer3.2in>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 = 2222;
        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 = 0 });
            }

            var def = Builders<Counter>.Update.Inc(t => t.seq, 1);
            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, 0);
            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 == 0)
            {
                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 == 0)
                {
                    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 > 0)
            {
                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 > 0);
            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 > 0);
            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 = 0;
            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 > 0).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 > 0).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 == "张冬林");

结果截图：