码迷,mamicode.com
首页 > 数据库 > 详细

MongoDB学习笔记~MongoDBRepository仓储的实现

时间:2015-04-08 12:46:26      阅读:176      评论:0      收藏:0      [点我收藏+]

标签:

仓储大叔,只要是持久化的东西,都要把它和仓储撤上关系,为啥,为的是开发人员在使用时统一,高可用及方便在各种方式之间实现动态的切换,如ef与redis和mongoDB的切换,你完成可以通过IRepository接口再配合IOC来实现,方便致极!

之间写过一个redis仓储xml仓储,感兴趣的同学可以先去看看,呵呵。

MongoDB在实现仓储时,先要知道一些概念,即它的一些connectionstring,即连接串

  <connectionStrings>
    <add name="NormTests" connectionString="mongodb://Username:Password@server:port/dbName/query"/>
  </connectionStrings>

对于大叔的MongoDBRepository,把它进行了拆分,使用Appsetting进行分别的设置

  <appSettings file="config.user">
    <add key="host" value="localhost:27017"/>
    <add key="dbName" value=""/>
    <add key="userName" value=""/>
    <add key="password" value=""/>
  </appSettings>

如果要配置读写分离,那么第一个host为主库,后面的为从库,如下面的字符串,将写操作定在主库,读操作定在各个从库

mongodb://server1,server2,server3/?slaveOk=true

下面看一下源代码

namespace MongoDb.Data.Core
{
    /// <summary>
    /// 通过MongoDb实现数据的持久化
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    public class MongoDBRepository<TEntity> :
        IExtensionRepository<TEntity> where TEntity : class
    {
        #region ConnectionString
        private static readonly string _connectionStringHost = ConfigurationManager.AppSettings["host"];
        private static readonly string _dbName = ConfigurationManager.AppSettings["dbName"];
        private static readonly string _userName = ConfigurationManager.AppSettings["userName"];
        private static readonly string _password = ConfigurationManager.AppSettings["password"];

        public static string ConnectionString(string options)
        {
            var database = _dbName;
            var userName = _userName;
            var password = _password;
            var authentication = string.Empty;
            var host = string.Empty;
            if (userName != null)
            {
                authentication = string.Concat(userName, :, password, @);
            }
            if (!string.IsNullOrEmpty(options) && !options.StartsWith("?"))
            {
                options = string.Concat(?, options);
            }
            host = string.IsNullOrEmpty(_connectionStringHost) ? "localhost" : _connectionStringHost;
            database = database ?? "Test";
            //mongodb://[username:password@]host1[:port1][,host2[:port2],…[,hostN[:portN]]][/[database][?options]]
            return string.Format("mongodb://{0}{1}/{2}{3}?{4}", authentication, host, database, options);
        }
        public static string ConnectionString()
        {
            return ConnectionString(null);
        }

        #endregion

        #region Public Properties
        public IMongoCollection<TEntity> Table
        {
            get
            {
                using (var mongo = Mongo.Create(ConnectionString()))
                {
                    return mongo.Database.GetCollection<TEntity>(typeof(TEntity).Name);
                }
            }
        }
        #endregion
        #region IRepository<TEntity> 成员

        public void SetDbContext(IUnitOfWork unitOfWork)
        {
            throw new NotImplementedException();
        }

        public void Insert(TEntity item)
        {
            using (var mongo = Mongo.Create(ConnectionString()))
            {
                var table = mongo.Database.GetCollection<TEntity>(typeof(TEntity).Name);
                table.Insert(item);
            }
        }

        public void Delete(TEntity item)
        {
            using (var mongo = Mongo.Create(ConnectionString()))
            {
                var table = mongo.Database.GetCollection<TEntity>(typeof(TEntity).Name);
                table.Delete(item);
            }
        }

        public void Update(TEntity item)
        {
            using (var mongo = Mongo.Create(ConnectionString()))
            {
                var table = mongo.Database.GetCollection<TEntity>(typeof(TEntity).Name);
                table.Save(item);
            }
        }

        public IQueryable<TEntity> GetModel()
        {
            using (var mongo = Mongo.Create(ConnectionString()))
            {
                return mongo.Database.GetCollection<TEntity>(typeof(TEntity).Name).AsQueryable();
            }
        }

        public TEntity Find(params object[] id)
        {
            using (var mongo = Mongo.Create(ConnectionString()))
            {
                return mongo.Database.GetCollection<TEntity>(typeof(TEntity).Name).FindOne(id);
            }
        }

        #endregion

        #region IExtensionRepository<TEntity> 成员

        public void Insert(IEnumerable<TEntity> item)
        {
            using (var mongo = Mongo.Create(ConnectionString()))
            {
                var table = mongo.Database.GetCollection<TEntity>(typeof(TEntity).Name);
                item.ToList().ForEach(i =>
                {
                    table.Insert(i);
                });
            }
        }

        public void Update(IEnumerable<TEntity> item)
        {
            using (var mongo = Mongo.Create(ConnectionString()))
            {
                var table = mongo.Database.GetCollection<TEntity>(typeof(TEntity).Name);
                item.ToList().ForEach(i =>
                {
                    table.Save(i);
                });
            }
        }

        public void Delete(IEnumerable<TEntity> item)
        {
            using (var mongo = Mongo.Create(ConnectionString()))
            {
                var table = mongo.Database.GetCollection<TEntity>(typeof(TEntity).Name);
                item.ToList().ForEach(i =>
                {
                    table.Delete(i);
                });
            }
        }

        public void Update<T>(System.Linq.Expressions.Expression<Action<T>> entity) where T : class
        {
            throw new NotImplementedException();
        }

        public IQueryable<TEntity> GetModel(System.Linq.Expressions.Expression<Func<TEntity, bool>> predicate)
        {
            using (var mongo = Mongo.Create(ConnectionString()))
            {
                return mongo.Database.GetCollection<TEntity>(typeof(TEntity).Name).AsQueryable().Where(predicate);
            }
        }

        public TEntity Find(System.Linq.Expressions.Expression<Func<TEntity, bool>> predicate)
        {
            using (var mongo = Mongo.Create(ConnectionString()))
            {
                return mongo.Database.GetCollection<TEntity>(typeof(TEntity).Name).AsQueryable().FirstOrDefault(predicate);
            }
        }

        public void BulkInsert(IEnumerable<TEntity> item, bool isRemoveIdentity)
        {
            throw new NotImplementedException();
        }

        public void BulkInsert(IEnumerable<TEntity> item)
        {
            throw new NotImplementedException();
        }

        public void BulkUpdate(IEnumerable<TEntity> item, params string[] fieldParams)
        {
            throw new NotImplementedException();
        }

        public void BulkDelete(IEnumerable<TEntity> item)
        {
            throw new NotImplementedException();
        }

        public event Action<SavedEventArgs> AfterSaved;

        public event Action<SavedEventArgs> BeforeSaved;

        public IQueryable<TEntity> GetModel(Frameworks.Entity.Core.Specification.ISpecification<TEntity> specification)
        {
            throw new NotImplementedException();
        }

        public TEntity Find(Frameworks.Entity.Core.Specification.ISpecification<TEntity> specification)
        {
            return GetModel(specification).FirstOrDefault();
        }

        public IQueryable<TEntity> GetModel(Action<IOrderable<TEntity>> orderBy, Frameworks.Entity.Core.Specification.ISpecification<TEntity> specification)
        {
            var linq = new Orderable<TEntity>(GetModel(specification));
            orderBy(linq);
            return linq.Queryable;
        }

        #endregion

        #region IRepositoryAsync<TEntity> 成员

        public Task InsertAsync(TEntity item)
        {
            throw new NotImplementedException();
        }

        public Task DeleteAsync(TEntity item)
        {
            throw new NotImplementedException();
        }

        public Task UpdateAsync(TEntity item)
        {
            throw new NotImplementedException();
        }

        public Task InsertAsync(IEnumerable<TEntity> item)
        {
            throw new NotImplementedException();
        }

        public Task UpdateAsync(IEnumerable<TEntity> item)
        {
            throw new NotImplementedException();
        }

        public Task DeleteAsync(IEnumerable<TEntity> item)
        {
            throw new NotImplementedException();
        }

        public Task BulkInsertAsync(IEnumerable<TEntity> item, bool isRemoveIdentity)
        {
            throw new NotImplementedException();
        }

        public Task BulkInsertAsync(IEnumerable<TEntity> item)
        {
            throw new NotImplementedException();
        }

        public Task BulkUpdateAsync(IEnumerable<TEntity> item, params string[] fieldParams)
        {
            throw new NotImplementedException();
        }

        public Task BulkDeleteAsync(IEnumerable<TEntity> item)
        {
            throw new NotImplementedException();
        }

        #endregion

        #region IOrderableRepository<TEntity> 成员

        public IQueryable<TEntity> GetModel(Action<IOrderable<TEntity>> orderBy)
        {
            var linq = new Orderable<TEntity>(GetModel());
            orderBy(linq);
            return linq.Queryable;
        }

        public IQueryable<TEntity> GetModel(Action<IOrderable<TEntity>> orderBy, System.Linq.Expressions.Expression<Func<TEntity, bool>> predicate)
        {
            var linq = new Orderable<TEntity>(GetModel(predicate));
            orderBy(linq);
            return linq.Queryable;
        }

        #endregion
    }
}

 

MongoDB学习笔记~MongoDBRepository仓储的实现

标签:

原文地址:http://www.cnblogs.com/lori/p/4402018.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!