Come faccio a mappare elenchi di oggetti nidificati con Dapper

Attualmente sto usando Entity Framework per il mio accesso al database, ma voglio dare un'occhiata a Dapper. Ho classi come questa:

public class Course{
   public string Title{get;set;}
   public IList<Location> Locations {get;set;}
   ...
}

public class Location{
   public string Name {get;set;}
   ...
}

Quindi un corso può essere tenuto in diversi luoghi. Entity Framework esegue il mapping per me, quindi il mio oggetto Course viene popolato con un elenco di posizioni. Come dovrei farlo con Dapper, è anche possibile o devo farlo in diversi passaggi di query?

Dapper non è un ORM in piena regola, non gestisce la generazione magica di query e simili.

Per il tuo esempio particolare, probabilmente funzionerebbe quanto segue:

Prendi i corsi:

var courses = cnn.Query<Course>("select * from Courses where Category = 1 Order by CreationDate");

Prendi la mappatura pertinente:

var mappings = cnn.Query<CourseLocation>(
   "select * from CourseLocations where CourseId in @Ids", 
    new {Ids = courses.Select(c => c.Id).Distinct()});

Prendi le posizioni pertinenti

var locations = cnn.Query<Location>(
   "select * from Locations where Id in @Ids",
   new {Ids = mappings.Select(m => m.LocationId).Distinct()}
);

Mappa tutto

Lasciando questo al lettore, crei alcune mappe e ripeti i tuoi corsi popolando le posizioni.

Attenzione, il intrucco funzionerà se hai meno di 2100 ricerche (Sql Server), se ne hai di più probabilmente vorrai modificare la query select * from CourseLocations where CourseId in (select Id from Courses ... )se questo è il caso puoi anche estrarre tutti i risultati in una volta usandoQueryMultiple

In alternativa, puoi utilizzare una query con una ricerca:

var lookup = new Dictionary<int, Course>();
conn.Query<Course, Location, Course>(@"
    SELECT c.*, l.*
    FROM Course c
    INNER JOIN Location l ON c.LocationId = l.Id                    
    ", (c, l) => {
        Course course;
        if (!lookup.TryGetValue(c.Id, out course))
            lookup.Add(c.Id, course = c);
        if (course.Locations == null) 
            course.Locations = new List<Location>();
        course.Locations.Add(l); /* Add locations to course */
        return course;
     }).AsQueryable();
var resultList = lookup.Values;

Vedi qui https://www.tritac.com/blog/dappernet-by-example/

Non c'è bisogno del lookupdizionario

var coursesWithLocations = 
    conn.Query<Course, Location, Course>(@"
        SELECT c.*, l.*
        FROM Course c
        INNER JOIN Location l ON c.LocationId = l.Id                    
        ", (course, location) => {
            course.Locations = course.Locations ?? new List<Location>();
            course.Locations.Add(location); 
            return course;
        }).AsQueryable();

So di essere davvero in ritardo, ma c'è un'altra opzione. Puoi usare QueryMultiple qui. Qualcosa come questo:

var results = cnn.QueryMultiple(@"
    SELECT * 
      FROM Courses 
     WHERE Category = 1 
  ORDER BY CreationDate
          ; 
    SELECT A.*
          ,B.CourseId 
      FROM Locations A 
INNER JOIN CourseLocations B 
        ON A.LocationId = B.LocationId 
INNER JOIN Course C 
        ON B.CourseId = B.CourseId 
       AND C.Category = 1
");

var courses = results.Read<Course>();
var locations = results.Read<Location>(); //(Location will have that extra CourseId on it for the next part)
foreach (var course in courses) {
   course.Locations = locations.Where(a => a.CourseId == course.CourseId).ToList();
}

Scusa il ritardo alla festa (come sempre). Per me, è più facile usare un Dictionary, come ha fatto Jeroen K , in termini di prestazioni e leggibilità. Inoltre, per evitare la moltiplicazione delle intestazioni tra le posizioni , utilizzo Distinct()per rimuovere potenziali duplicati:

string query = @"SELECT c.*, l.*
    FROM Course c
    INNER JOIN Location l ON c.LocationId = l.Id";
using (SqlConnection conn = DB.getConnection())
{
    conn.Open();
    var courseDictionary = new Dictionary<Guid, Course>();
    var list = conn.Query<Course, Location, Course>(
        query,
        (course, location) =>
        {
            if (!courseDictionary.TryGetValue(course.Id, out Course courseEntry))
            {
                courseEntry = course;
                courseEntry.Locations = courseEntry.Locations ?? new List<Location>();
                courseDictionary.Add(courseEntry.Id, courseEntry);
            }

            courseEntry.Locations.Add(location);
            return courseEntry;
        },
        splitOn: "Id")
    .Distinct()
    .ToList();

    return list;
}

Manca qualcosa. Se non si specifica ogni campo da Locationsnella query SQL, l'oggetto Locationnon può essere riempito. Guarda:

var lookup = new Dictionary<int, Course>()
conn.Query<Course, Location, Course>(@"
    SELECT c.*, l.Name, l.otherField, l.secondField
    FROM Course c
    INNER JOIN Location l ON c.LocationId = l.Id                    
    ", (c, l) => {
        Course course;
        if (!lookup.TryGetValue(c.Id, out course)) {
            lookup.Add(c.Id, course = c);
        }
        if (course.Locations == null) 
            course.Locations = new List<Location>();
        course.Locations.Add(a);
        return course;
     },
     ).AsQueryable();
var resultList = lookup.Values;

Usando l.*nella query, avevo l'elenco delle posizioni ma senza dati.

Non sono sicuro che qualcuno ne abbia bisogno, ma ne ho una versione dinamica senza Modello per una codifica rapida e flessibile.

var lookup = new Dictionary<int, dynamic>();
conn.Query<dynamic, dynamic, dynamic>(@"
    SELECT A.*, B.*
    FROM Client A
    INNER JOIN Instance B ON A.ClientID = B.ClientID                
    ", (A, B) => {
        // If dict has no key, allocate new obj
        // with another level of array
        if (!lookup.ContainsKey(A.ClientID)) {
            lookup[A.ClientID] = new {
                ClientID = A.ClientID,
                ClientName = A.Name,                                        
                Instances = new List<dynamic>()
            };
        }

        // Add each instance                                
        lookup[A.ClientID].Instances.Add(new {
            InstanceName = B.Name,
            BaseURL = B.BaseURL,
            WebAppPath = B.WebAppPath
        });

        return lookup[A.ClientID];
    }, splitOn: "ClientID,InstanceID").AsQueryable();

var resultList = lookup.Values;
return resultList;