Entity Framework database first approach using stored procedure

Question

I am creating a project that uses Entity framework Database first approach. The .edmx is currently generated and is in my data access layer project.

I have created a function import call GetAllTeam and corresponding complex type call TeamResult. I am trying to return the data to business layer by calling my function import, populating the complex type in the data access layer.

In my business layer I shall then map the complex type to business object and return to my web api. I would like to know if my approach is correct. Do I need to create a separate class project called entities with a class called team and then AutoMap that class with TeamResult the complex type and then return to the business layer or is it fine directly sending the TeamResult to the business layer.

Let me also know if there is any other issue with this approach.

Please see the code below

Data access layer:

public class TeamRepository
{
        public IEnumerable<TeamResult> GetAllTeam()
        {
            using (var mcrContext = new MCREntities1())
            {
                return (from team in mcrContext.GetAllTeam()

                        select new TeamResult
                        {
                            TeamName = team.TeamName,
                            TeamDescription = team.TeamDescription,
                            Code = team.Code

                        }).ToList();
            }
        }
}

Business logic layer:

public class TeamService : ITeamService
{
        private readonly ITeamRepository _teamRepository;

        public TeamService(ITeamRepository teamRepository)
        {
            _teamRepository = teamRepository;
        }

        public IEnumerable<TeamDto> GetTeam()
        {
            IEnumerable<TeamResult> team = _teamRepository.GetAllTeam();

            if (team != null)
            {
                foreach (var t in team)
                {
                    yield return Mapper.Map<TeamDto>(t);
                }
            }

            yield break;
        }
}

public class DomainToDtoMapping : Profile
{
        public DomainToDtoMapping()
        {
            CreateMap<TeamResult, TeamDto>().ReverseMap();
        }

        public override string ProfileName
        {
            get { return "DomainToDtoMapping"; }
        }
}

Web Api:

public class TeamController : ApiController
{
        private readonly ITeamService _teamServices;

        public TeamController(ITeamService  _teamServices)
        {
            _teamServices = teamServices;
        }

        public HttpResponseMessage Get()
        {
            var teams = _teamServices.GetTeam();

            if (teams != null)
            {
                var teamEntities = teams as List<TeamDto> ?? teams.ToList();

                if (teamEntities.Any())
                    return Request.CreateResponse(HttpStatusCode.OK, teamEntities);
            }

            return Request.CreateErrorResponse(HttpStatusCode.NotFound, "Team not found");
        }
}

Answer 1

Personally, I think you are doing this just fine. Having another entity to map the stored procedure to before returning it from the repository wouldn't add any value because you are returning exactly what the stored procedure exposes already.

The business layer needs to know about any entities that the Repository can return and then map it to something to return later. This all looks good to me! :)