Consolidating methods and using projections

Author: jbogard

ContosoUniversity/Features/Instructors/CreateEdit.cs

@@ -84,10 +84,7 @@ public class QueryHandler : IAsyncRequestHandler<Query, Command>
         {
             private readonly SchoolContext _db;
 
-            public QueryHandler(SchoolContext db)
-            {
-                _db = db;
-            }
+            public QueryHandler(SchoolContext db) => _db = db;
 
             public async Task<Command> Handle(Query message)
             {
@@ -101,9 +98,8 @@ public async Task<Command> Handle(Query message)
                     model = await _db.Instructors
                         .Include(m => m.CourseAssignments)
                         .ThenInclude(ca => ca.Course)
-                        .Include(m => m.OfficeAssignment)
                         .Where(i => i.Id == message.Id)
-                        .Map()
+                        .ProjectTo<Command>()
                         .SingleOrDefaultAsync<Command>();
 
                     //.ProjectTo<Command>()
@@ -134,10 +130,7 @@ public class CommandHandler : IAsyncRequestHandler<Command, int>
         {
             private readonly SchoolContext _db;
 
-            public CommandHandler(SchoolContext db)
-            {
-                _db = db;
-            }
+            public CommandHandler(SchoolContext db) => _db = db;
 
             public async Task<int> Handle(Command message)
             {

ContosoUniversity/Features/Instructors/Index.cs

@@ -72,23 +72,19 @@ public class Handler : IAsyncRequestHandler<Query, Model>
         {
             private readonly SchoolContext _db;
 
-            public Handler(SchoolContext db)
-            {
-                _db = db;
-            }
+            public Handler(SchoolContext db) => _db = db;
 
             public async Task<Model> Handle(Query message)
             {
                 var instructors = await _db.Instructors
-                    .Include(i => i.OfficeAssignment)
                     .Include(i => i.CourseAssignments)
                     .ThenInclude(c => c.Course)
                     .OrderBy(i => i.LastName)
-                    .Map()
-                    .ToListAsync<Model.Instructor>()
+                    .ProjectTo<Model.Instructor>()
+                    .ToListAsync()
                     ;
 
-                // EF Core cannot project child collections
+                // EF Core cannot project child collections w/o Include
                 // See https://github.com/aspnet/EntityFrameworkCore/issues/9128
                 //var instructors = await _db.Instructors
                 //    .OrderBy(i => i.LastName)

ContosoUniversity/Features/MappingExtensions.cs

@@ -1,57 +1,11 @@
-using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
 using System.Threading.Tasks;
-using AutoMapper;
-using AutoMapper.QueryableExtensions;
-using Microsoft.EntityFrameworkCore;
 
 namespace ContosoUniversity.Features
 {
     public static class MappingExtensions
     {
-        public static ICollectionMapperExpression Map<TSource>(this IEnumerable<TSource> items)
-            => new CollectionMapperExpression<TSource>(items);
-
-        public static IQueryableExpression Map<TSource>(this IQueryable<TSource> items)
-            => new QueryableExpression<TSource>(items);
-
-        private class CollectionMapperExpression<TSource> : ICollectionMapperExpression
-        {
-            private readonly IEnumerable<TSource> _items;
-
-            public CollectionMapperExpression(IEnumerable<TSource> items) 
-                => _items = items;
-
-            public IList<TDestination> ToList<TDestination>() => _items.Select(Mapper.Map<TSource, TDestination>).ToList();
-        }
-
-        private class QueryableExpression<TSource> : IQueryableExpression
-        {
-            private readonly IQueryable<TSource> _items;
-
-            public QueryableExpression(IQueryable<TSource> items) 
-                => _items = items;
-
-            public async Task<IList<TDestination>> ToListAsync<TDestination>()
-                => (await _items.ToListAsync()).Select(src => Mapper.Map<TSource, TDestination>(src)).ToList();
-
-            public Task<PaginatedList<TDestination>> ToPaginatedListAsync<TDestination>(int pageNumber, int pageSize)
-                => PaginatedList<TDestination>.CreateAsync(_items.ProjectTo<TDestination>(), pageNumber, pageSize);
-
-            public async Task<TDestination> SingleOrDefaultAsync<TDestination>() 
-                => Mapper.Map<TSource, TDestination>(await _items.SingleOrDefaultAsync());
-        }
-    }
-
-    public interface ICollectionMapperExpression
-    {
-        IList<TDestination> ToList<TDestination>();
-    }
-
-    public interface IQueryableExpression
-    {
-        Task<IList<TDestination>> ToListAsync<TDestination>();
-        Task<TDestination> SingleOrDefaultAsync<TDestination>();
-        Task<PaginatedList<TDestination>> ToPaginatedListAsync<TDestination>(int pageNumber, int pageSize);
+        public static Task<PaginatedList<TDestination>> PaginatedListAsync<TDestination>(this IQueryable<TDestination> queryable, int pageNumber, int pageSize)
+            => PaginatedList<TDestination>.CreateAsync(queryable, pageNumber, pageSize);
     }
 }

ContosoUniversity/Features/Students/Index.cs

@@ -2,6 +2,7 @@
 using System.ComponentModel.DataAnnotations;
 using System.Linq;
 using System.Threading.Tasks;
+using AutoMapper.QueryableExtensions;
 using ContosoUniversity.Data;
 using ContosoUniversity.Models;
 using MediatR;
@@ -42,10 +43,7 @@ public class QueryHandler : IAsyncRequestHandler<Query, Result>
         {
             private readonly SchoolContext _db;
 
-            public QueryHandler(SchoolContext db)
-            {
-                _db = db;
-            }
+            public QueryHandler(SchoolContext db) => _db = db;
 
             public async Task<Result> Handle(Query message)
             {
@@ -92,7 +90,9 @@ public async Task<Result> Handle(Query message)
 
                 int pageSize = 3;
                 int pageNumber = (message.Page ?? 1);
-                model.Results = await students.Map().ToPaginatedListAsync<Model>(pageNumber, pageSize);
+                model.Results = await students
+                    .ProjectTo<Model>()
+                    .PaginatedListAsync(pageNumber, pageSize);
 
                 return model;
             }