Question

我正在创建一个Ntier解决方案，其中包括域对象，DataAccess层，服务层和Web API层。我正在使用AutoMapper来映射服务层中的Dtos和域对象。我想知道如何编写在服务层执行CRUD操作的逻辑。我写了一些映射。这是正确的映射方式还是有更好的方法来做到这一点，请在我编写获取，保存，更新，删除操作的地方纠正我。我基本上需要帮助来实现我的服务层。

调试代码时出现以下错误：

Mapper未初始化。使用适当的配置调用Initialize。如果您尝试通过容器或其他方式使用映射器实例，请确保您没有对静态Mapper.Map方法的任何调用，并且如果您正在使用ProjectTo或UseAsDataSource扩展方法，请确保传入适当的IConfigurationProvider实例。

我在GetPatient方法的以下代码行中收到错误：

yield return Mapper.Map<PatientDto>(patient);

域层

public class Patient : BaseEntity
    {
        public string FirstName { get; set; }

        public string LastName { get; set; }

        public DateTime DateOfBirth { get; set; }

        public char Gender { get; set; }

        public string Phone { get; set; }
  }

DataAccess Layer

   public class GenericRepository<TEntity> where TEntity : class
    {
        #region Private member variables...
        internal AppointmentBookingContext Context;
        internal DbSet<TEntity> DbSet;
        #endregion

        #region Public Constructor...
        /// <summary>
        /// Public Constructor,initializes privately declared local variables.
        /// </summary>
        /// <param name="context"></param>
        public GenericRepository(AppointmentBookingContext context)
        {
            this.Context = context;
            this.DbSet = context.Set<TEntity>();
        }
        #endregion

        #region Public member methods...

        /// <summary>
        /// generic Get method for Entities
        /// </summary>
        /// <returns></returns>
        public virtual IEnumerable<TEntity> Get()
        {
            IQueryable<TEntity> query = DbSet;
            return query.ToList();
        }

        /// <summary>
        /// Generic get method on the basis of id for Entities.
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public virtual TEntity GetByID(object id)
        {
            return DbSet.Find(id);
        }

        /// <summary>
        /// generic Insert method for the entities
        /// </summary>
        /// <param name="entity"></param>
        public virtual void Insert(TEntity entity)
        {
            DbSet.Add(entity);
        }

        /// <summary>
        /// Generic Delete method for the entities
        /// </summary>
        /// <param name="id"></param>
        public virtual void Delete(object id)
        {
            TEntity entityToDelete = DbSet.Find(id);
            Delete(entityToDelete);
        }

        /// <summary>
        /// Generic Delete method for the entities
        /// </summary>
        /// <param name="entityToDelete"></param>
        public virtual void Delete(TEntity entityToDelete)
        {
            if (Context.Entry(entityToDelete).State == EntityState.Detached)
            {
                DbSet.Attach(entityToDelete);
            }
            DbSet.Remove(entityToDelete);
        }

        /// <summary>
        /// Generic update method for the entities
        /// </summary>
        /// <param name="entityToUpdate"></param>
        public virtual void Update(TEntity entityToUpdate)
        {
            DbSet.Attach(entityToUpdate);
            Context.Entry(entityToUpdate).State = EntityState.Modified;
        }

        /// <summary>
        /// generic method to get many record on the basis of a condition.
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
        public virtual IEnumerable<TEntity> GetMany(Func<TEntity, bool> where)
        {
            return DbSet.Where(where).ToList();
        }

        /// <summary>
        /// generic method to get many record on the basis of a condition but query able.
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
        public virtual IQueryable<TEntity> GetManyQueryable(Func<TEntity, bool> where)
        {
            return DbSet.Where(where).AsQueryable();
        }

        /// <summary>
        /// generic get method , fetches data for the entities on the basis of condition.
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
        public TEntity Get(Func<TEntity, Boolean> where)
        {
            return DbSet.Where(where).FirstOrDefault<TEntity>();
        }

        /// <summary>
        /// generic delete method , deletes data for the entities on the basis of condition.
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
        public void Delete(Func<TEntity, Boolean> where)
        {
            IQueryable<TEntity> objects = DbSet.Where<TEntity>(where).AsQueryable();
            foreach (TEntity obj in objects)
                DbSet.Remove(obj);
        }

        /// <summary>
        /// generic method to fetch all the records from db
        /// </summary>
        /// <returns></returns>
        public virtual IEnumerable<TEntity> GetAll()
        {
            return DbSet.ToList();
        }

        /// <summary>
        /// Inclue multiple
        /// </summary>
        /// <param name="predicate"></param>
        /// <param name="include"></param>
        /// <returns></returns>
        public IQueryable<TEntity> GetWithInclude(
            System.Linq.Expressions.Expression<Func<TEntity,
            bool>> predicate, params string[] include)
        {
            IQueryable<TEntity> query = this.DbSet;
            query = include.Aggregate(query, (current, inc) => current.Include(inc));
            return query.Where(predicate);
        }

        /// <summary>
        /// Generic method to check if entity exists
        /// </summary>
        /// <param name="primaryKey"></param>
        /// <returns></returns>
        public bool Exists(object primaryKey)
        {
            return DbSet.Find(primaryKey) != null;
        }

        /// <summary>
        /// Gets a single record by the specified criteria (usually the unique identifier)
        /// </summary>
        /// <param name="predicate">Criteria to match on</param>
        /// <returns>A single record that matches the specified criteria</returns>
        public TEntity GetSingle(Func<TEntity, bool> predicate)
        {
            return DbSet.Single<TEntity>(predicate);
        }

        /// <summary>
        /// The first record matching the specified criteria
        /// </summary>
        /// <param name="predicate">Criteria to match on</param>
        /// <returns>A single record containing the first record matching the specified criteria</returns>
        public TEntity GetFirst(Func<TEntity, bool> predicate)
        {
            return DbSet.First<TEntity>(predicate);
        }


        #endregion
    }

服务层

PatientDto.cs

 public class PatientDto
    {
        public string FirstName { get; set; }

        public string LastName { get; set; }

        public DateTime DateOfBirth { get; set; }

        public char Gender { get; set; }

        public string Phone { get; set; }
}

AutoMapperConfiguration.cs

public class AutoMapperConfiguration
{
    public static void Configure()
    {
           Assembly[] assemblies = BuildManager.GetReferencedAssemblies().OfType<Assembly>().ToArray();
        Mapper.Initialize(cfg =>
        cfg.AddProfiles(AllClasses.FromAssemblies(assemblies)
        .Where(
        a =>
           a.FullName.EndsWith("Mapping"))));        }
}

DomainToDtoMapping.cs

   public class DomainToDtoMapping : Profile
    {

        public DomainToDtoMapping()
        {
          CreateMap<BaseEntity, BaseDto>().ReverseMap();
          CreateMap<Patient, PatientDto>().ReverseMap();

         }
}

IPatientService

   public interface IPatientService
    {
        IEnumerable<PatientDto> GetPatient();
        PatientDto GetPatientById(int id);
        int CreatePatient(PatientDto customer);
        bool UpdatePatient(PatientDto patient);
        bool DeletePatient(int patient);

    }

PatientService

public class PatientService : IPatientService
    {

        private readonly IUnitOfWork _unitOfWork;


public int CreatePatient(PatientDto patientDto)
    {
        using (var scope = new TransactionScope())
        {
            var patient = _unitOfWork.PatientRepository.GetByID(patientDto.Id);

            _unitOfWork.PatientRepository.Insert(patient);
            _unitOfWork.Save();
            scope.Complete();
            return patient.Id;
        }
    }

    public bool DeletePatient(int id)
    {
        var success = false;

        if (id > 0)
        {
            using (var scope = new TransactionScope())
            {
                var patient = _unitOfWork.PatientRepository.GetByID(id);
                if (patient != null)
                {

                    _unitOfWork.PatientRepository.Delete(patient);
                    _unitOfWork.Save();
                    scope.Complete();
                    success = true;
                }
            }
        }
        return success;
    }

    public IEnumerable<PatientDto> GetPatient()
    {
        var patient = _unitOfWork.PatientRepository.GetAll();
        if (patient != null)
        {
            yield return Mapper.Map<PatientDto>(patient);
        }
        yield return null;
    }

    public PatientDto GetPatientById(int id)
    {
        var patient = _unitOfWork.PatientRepository.GetByID(id);
        if (patient != null)
        {
            return Mapper.Map<PatientDto>(patient);
        }
        return null;

    }

    public bool UpdatePatient(PatientDto patientDto)
    {
        var success = false;

        if (patientDto != null)
        {
            using (var scope = new TransactionScope())
            {
                var patient = _unitOfWork.PatientRepository.GetByID(patientDto.Id);

                if (patient != null)
                {

                    _unitOfWork.PatientRepository.Update(patient);
                    _unitOfWork.Save();
                    scope.Complete();
                    success = true;
                }
            }
        }
        return success;
    }

在服务层中自动映射和实现Dtos

0 个答案: