Jak mapować listy zagnieżdżonych obiektów za pomocą Dapper

Obecnie używam Entity Framework do mojego dostępu do bazy danych, ale chcę rzucić okiem na Dapper. Mam takie zajęcia:

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

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

Tak więc jeden kurs może być prowadzony w kilku miejscach. Entity Framework wykonuje dla mnie mapowanie, więc mój obiekt kursu jest wypełniony listą lokalizacji. Jak mam to zrobić z Dapper, czy to w ogóle możliwe, czy też muszę to zrobić w kilku krokach zapytania?

Dapper nie jest w pełni rozwiniętym ORMem, nie obsługuje magicznego generowania zapytań i tym podobnych.

W twoim konkretnym przykładzie prawdopodobnie zadziałałoby:

Weź udział w kursach:

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

Pobierz odpowiednie mapowanie:

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

Chwyć odpowiednie lokalizacje

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

Mapuj to wszystko

Pozostawiając to czytelnikowi, tworzysz kilka map i iterujesz po swoich kursach zapełniających lokalizacje.

Zastrzeżeniein trik zadziała, jeśli masz mniej niż 2100 wyszukiwań (SQL Server), jeśli masz więcej prawdopodobnie chcesz zmienić zapytanie, aby select * from CourseLocations where CourseId in (select Id from Courses ... )jeśli jest to sprawa może równie dobrze można szarpać wszystkich wyników za jednym razem za pomocąQueryMultiple

Alternatywnie możesz użyć jednego zapytania z wyszukiwaniem:

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;

Zobacz tutaj https://www.tritac.com/blog/dappernet-by-example/

Nie ma potrzeby używania lookupsłownika

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();

Wiem, że jestem na to naprawdę spóźniony, ale jest inna opcja. Możesz użyć QueryMultiple tutaj. Coś takiego:

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();
}

Przepraszam, że spóźniłem się na imprezę (jak zawsze). Dla mnie łatwiej jest używać a Dictionary, tak jak zrobił to Jeroen K. , pod względem wydajności i czytelności. Ponadto, aby uniknąć mnożenia nagłówków w różnych lokalizacjach , używam Distinct()do usuwania potencjalnych duplikatów:

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;
}

Coś brakuje. Jeśli nie określisz każdego pola Locationsw zapytaniu SQL, obiekt Locationnie może zostać wypełniony. Spójrz:

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;

Używając l.*w zapytaniu, miałem listę lokalizacji, ale bez danych.

Nie jestem pewien, czy ktoś tego potrzebuje, ale mam dynamiczną wersję bez modelu do szybkiego i elastycznego kodowania.

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;