将不确定变为确定~接口应该是什么

回到目录

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

书上说：“接口规定了一组操作的规范，它将一些不相关的对象联系在一起”，说是这样说，但在实际当中我们应该如何去用接口，如何去用好接口呢？

事实上，我一直认为，在面向对象中，接口就是大哥大，用好接口，理解好接口，你对面向对象的认识也将上升一个新的台阶，接口不可遗忘的功能就是它实现了面向对象的多态性，多态，即一种对象，在接受指定信息时，实现指定的对象实例，这其实就是我对多态的比较直观的理解。

一个用户操作的接口可能是这样被定义：

    /// <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呢，呵呵。

回到目录