回到目錄

倉儲大叔，只要是持久化的東西，都要把它和倉儲撤上關係，為啥，為的是開發人員在使用時統一，高可用及方便在各種方式之間實現動態的切換，如ef與redis和mongoDB的切換，你完成可以通過IRepository介面再配合IOC來實現，方便致極！

之間寫過一個redis倉儲和xml倉儲，感興趣的同學可以先去看看，呵呵。

MongoDB在實現倉儲時，先要知道一些概念，即它的一些connectionstring，即連線串

  <connectionStrings>
    <add name="NormTests" connectionString="mongodb://Username:
 
[email protected]server:port/dbName/query"/>
  </connectionStrings>

對於大叔的MongoDBRepository，把它進行了拆分，使用Appsetting進行分別的設定

  <appSettings file="config.user">
    <add key="MongoDB_Host" value="localhost:27017"/>
    <add key="MongoDB_DbName" value=""/>
    <add key="MongoDB_UserName" value=""/>
    <add key="MongoDB_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:[email protected]]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)
                    .Find(new { ID = new ObjectId(id[0].ToString()) })
                    .FirstOrDefault();
             }
        }

        #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
    }
}

 回到目錄