將不確定變為確定~接口應該是什么

回到目錄

接口到底是什么，應該如何去使用它呢？

書上說：“接口規定了一組操作的規范，它將一些不相關的對象聯系在一起”，說是這樣說，但在實際當中我們應該如何去用接口，如何去用好接口呢？

事實上，我一直認為，在面向對象中，接口就是大哥大，用好接口，理解好接口，你對面向對象的認識也將上升一個新的台階，接口不可遺忘的功能就是它實現了面向對象的多態性，多態，即一種對象，在接受指定信息時，實現指定的對象實例，這其實就是我對多態的比較直觀的理解。

一個用戶操作的接口可能是這樣被定義：

    /// <summary>
    /// 用戶相關接口規范
    /// </summary>
    public interface IUserRepository : Data.IRepository<UserBases>
    {
        /// <summary>
        /// 注冊流程
        /// </summary>
        /// <param name="entity"></param>
        VMessage RegisterUser(UserBases entity);

        void UpdateUser(UserBases entity);
        /// <summary>
        /// 登陸
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        VMessage Login(UserBases entity);

        /// <summary>
        /// 修改密碼
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        VMessage ChangePassword(UserBases entity);
     }

但對於它的實現，我們可以有多種，如可以是sqlserver的，而對於sqlserver來說，又可以是linq to sql的,ado.net的及ef的等等。

而對於一個用戶操作的實現類，它將被動的去實現IUserRepository的基接口IRepository,代碼如下：

  /// <summary>
    /// 用戶操作實現類
    /// sqlserver-linq to sql實現
    /// </summary>
    public class UserRepository : Car_RentalRepositoryBase, IUserRepository
    {

        #region IUserRepository 成員

        public VMessage RegisterUser(UserBases entity)
        {
            entity.Password = Utility.EncryptString(entity.Password, Utility.EncryptorType.MD5);
            VMessage vm = new VMessage();
            try
            {
                base.InsertEntity(entity);
                vm.IsComplete = true;
            }
            catch (Exception)
            {
                vm.IsComplete = false;
                throw;
            }
            return vm;

        }

        public void UpdateUser(UserBases entity)
        {
            DB.SubmitChanges();
        }

        public VMessage Login(UserBases entity)
        {
            VMessage vm = new VMessage();
            try
            {
                entity = this.GetModel().Where(i => i.Name == entity.Name && i.Password == Utility.EncryptString(entity.Password, Utility.EncryptorType.MD5)).FirstOrDefault();
                if (entity != null)
                {
                    vm.IsComplete = true;
                    vm.Entity = entity;
                }
                else
                    vm.IsComplete = false;
            }
            catch (Exception)
            {
                vm.IsComplete = false;
                throw;
            }
            return vm;
        }

        public VMessage ChangePassword(UserBases entity)
        {
            VMessage vm = new VMessage();
            try
            {
                vm = this.Login(entity);

                if (vm.IsComplete)
                {
                    entity = vm.Entity as UserBases;
                    entity.Password = Utility.EncryptString(entity.NewPassword, Utility.EncryptorType.MD5);
                    this.Update(entity);
                    vm.IsComplete = true;
                }
                else
                    vm.IsComplete = false;
            }
            catch (Exception)
            {
                vm.IsComplete = false;
                throw;
            }
            return vm;
        }
        #endregion

        #region IRepository<UserBases> 成員

        public void Update(UserBases entity)
        {
            base.UpdateEntity(entity);
        }

        public void Update(IList<UserBases> list)
        {
            list.ToList().ForEach(entity => { this.Update(entity); });
        }

        public void Insert(UserBases entity)
        {
            base.InsertEntity(entity);
        }

        public void Insert(IList<UserBases> list)
        {
            list.ToList().ForEach(entity => { this.Insert(entity); });
        }

        public UserBases InsertGetIDENTITY(UserBases entity)
        {
            base.InsertEntity(entity);
            return base.Find<UserBases>(entity.UserID);
        }

        public void Delete(UserBases entity)
        {
            base.DeleteEntity(entity);
        }

        public void Delete(IList<UserBases> list)
        {
            list.ToList().ForEach(entity => { this.Delete(entity); });
        }

        public IQueryable<UserBases> GetModel()
        {
            return base.GetEntities<UserBases>().Select(item => new UserBases_Ext
            {
                CreateDate = item.CreateDate,
                Email = item.Email,
                Name = item.Name,
                Status = item.Status,
                UpdateDate = item.UpdateDate,
                UserID = item.UserID,
                Password = item.Password,
                ConfirmCode = item.ConfirmCode,
                ConfirmPassword = item.ConfirmPassword,
                IDNumber = item.IDNumber,
                IDType = item.IDType,
                QQ = item.QQ,
                Tel = item.Tel,
                TelVerify = item.TelVerify,
            });
        }

        public UserBases Find(params object[] keyValues)
        {
            return base.Find<UserBases>(keyValues);
        }

        #endregion
    }

而在業務層去調用時，你可以使用IOC去建立實例，也可以在程序里寫死，但它為業務層開放時，盡量是“構架方法”注入式的，以下是商品業務模塊的代碼片斷：

  /// <summary>
    /// 商品模塊實現
    /// </summary>
    public class ProductService : ServiceBase, IProductService
    {
        IProductRepository iProductRepository = null;
        /// <summary>
        /// 默認構造方法
        /// </summary>
        public ProductService()
            : this(new ProductRepository())
        {

        }
        /// <summary>
        /// 構造方法，可以在建立實例時進行實現方式的選擇
        /// </summary>
        /// <param name="_iProductRepository"></param>
        public ProductService(IProductRepository _iProductRepository)
        {
            iProductRepository = _iProductRepo

而這樣，在上一層就可以轉入接口的一個實現就可以了，這樣是否方便TDD呢，呵呵。

回到目錄