Wie schreibe ich eine zu viele Abfragen in Dapper.Net?

Question 1

Ich habe diesen Code geschrieben, um eine bis viele Beziehungen zu projizieren, aber er funktioniert nicht:

using (var connection = new SqlConnection(connectionString))
{
   connection.Open();

   IEnumerable<Store> stores = connection.Query<Store, IEnumerable<Employee>, Store>
                        (@"Select Stores.Id as StoreId, Stores.Name, 
                                  Employees.Id as EmployeeId, Employees.FirstName,
                                  Employees.LastName, Employees.StoreId 
                           from Store Stores 
                           INNER JOIN Employee Employees ON Stores.Id = Employees.StoreId",
                        (a, s) => { a.Employees = s; return a; }, 
                        splitOn: "EmployeeId");

   foreach (var store in stores)
   {
       Console.WriteLine(store.Name);
   }
}

Kann jemand den Fehler erkennen?

BEARBEITEN:

Dies sind meine Entitäten:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public double Price { get; set; }
    public IList<Store> Stores { get; set; }

    public Product()
    {
        Stores = new List<Store>();
    }
}

public class Store
{
    public int Id { get; set; }
    public string Name { get; set; }
    public IEnumerable<Product> Products { get; set; }
    public IEnumerable<Employee> Employees { get; set; }

    public Store()
    {
        Products = new List<Product>();
        Employees = new List<Employee>();
    }
}

BEARBEITEN:

Ich ändere die Abfrage in:

IEnumerable<Store> stores = connection.Query<Store, List<Employee>, Store>
        (@"Select Stores.Id as StoreId ,Stores.Name,Employees.Id as EmployeeId,
           Employees.FirstName,Employees.LastName,Employees.StoreId 
           from Store Stores INNER JOIN Employee Employees 
           ON Stores.Id = Employees.StoreId",
         (a, s) => { a.Employees = s; return a; }, splitOn: "EmployeeId");

und ich werde Ausnahmen los! Mitarbeiter werden jedoch überhaupt nicht zugeordnet. Ich bin mir immer noch nicht sicher, mit welchem Problem es bei der IEnumerable<Employee>ersten Abfrage war.

Question 2

Dieser Beitrag zeigt, wie Sie eine stark normalisierte SQL-Datenbank abfragen und das Ergebnis einer Reihe hoch verschachtelter C # POCO-Objekte zuordnen.

Zutaten:

8 Zeilen C #.
Einige ziemlich einfache SQL, die einige Joins verwendet.
Zwei großartige Bibliotheken.

Die Einsicht, die es mir ermöglichte, dieses Problem zu lösen, besteht darin, das MicroORMvon zu trennen mapping the result back to the POCO Entities. Daher verwenden wir zwei separate Bibliotheken:

Dapper als MicroORM.
Slapper.Automapper für das Mapping.

Im Wesentlichen verwenden wir Dapper , um die Datenbank abzufragen, und dann Slapper.Automapper , um das Ergebnis direkt in unsere POCOs abzubilden.

Vorteile

Einfachheit . Es sind weniger als 8 Codezeilen. Ich finde das viel einfacher zu verstehen, zu debuggen und zu ändern.
Weniger Code . Ein paar Codezeilen sind alles Slapper.Automapper muss alles verarbeiten, was Sie darauf werfen, selbst wenn wir einen komplexen verschachtelten POCO haben (dh POCO enthält, List<MyClass1>der wiederum enthält List<MySubClass2>, usw.).
Geschwindigkeit . Beide Bibliotheken verfügen über ein außerordentliches Maß an Optimierung und Caching, sodass sie fast so schnell ausgeführt werden wie handgestimmte ADO.NET-Abfragen.
Trennung von Bedenken . Wir können das MicroORM gegen ein anderes austauschen, und das Mapping funktioniert immer noch und umgekehrt.
Flexibilität . Slapper.Automapper verarbeitet beliebig verschachtelte Hierarchien und ist nicht auf einige Verschachtelungsebenen beschränkt. Wir können leicht schnelle Änderungen vornehmen, und alles wird noch funktionieren.
Debuggen . Wir können zuerst sehen, dass die SQL-Abfrage ordnungsgemäß funktioniert, und dann überprüfen, ob das Ergebnis der SQL-Abfrage ordnungsgemäß den POCO-Zielentitäten zugeordnet ist.
Einfache Entwicklung in SQL . Ich finde, dass das Erstellen abgeflachter Abfragen mit inner joins, um flache Ergebnisse zurückzugeben, viel einfacher ist als das Erstellen mehrerer select-Anweisungen mit Stitching auf der Clientseite.
Optimierte Abfragen in SQL . In einer stark normalisierten Datenbank ermöglicht das Erstellen einer flachen Abfrage der SQL-Engine, erweiterte Optimierungen auf das Ganze anzuwenden, die normalerweise nicht möglich wären, wenn viele kleine Einzelabfragen erstellt und ausgeführt würden.
Vertrauen . Dapper ist das Backend für StackOverflow, und Randy Burden ist ein bisschen ein Superstar. Muss ich noch mehr sagen?
Entwicklungsgeschwindigkeit. Ich war in der Lage, einige außerordentlich komplexe Abfragen mit vielen Verschachtelungsebenen durchzuführen, und die Entwicklungszeit war ziemlich gering.
Weniger Bugs. Ich habe es einmal geschrieben, es hat einfach funktioniert, und diese Technik hilft jetzt, ein FTSE-Unternehmen mit Strom zu versorgen. Es gab so wenig Code, dass es kein unerwartetes Verhalten gab.

Nachteile

Skalierung über 1.000.000 Zeilen zurückgegeben. Funktioniert gut, wenn <100.000 Zeilen zurückgegeben werden. Wenn wir jedoch mehr als 1.000.000 Zeilen zurückbringen, sollten wir den Datenverkehr zwischen uns und dem SQL Server nicht reduzieren inner join(wodurch Duplikate zurückgebracht werden), sondern stattdessen mehrere selectAnweisungen verwenden und alles wieder zusammenfügen Client-Seite (siehe die anderen Antworten auf dieser Seite).
Diese Technik ist abfrageorientiert . Ich habe diese Technik nicht zum Schreiben in die Datenbank verwendet, aber ich bin sicher, dass Dapper dies mit etwas mehr Arbeit mehr als tun kann, da StackOverflow selbst Dapper als Data Access Layer (DAL) verwendet.

Leistungstest

In meinen Tests hat Slapper.Automapper den von Dapper zurückgegebenen Ergebnissen einen kleinen Overhead hinzugefügt, was bedeutete, dass es immer noch 10x schneller als Entity Framework war und die Kombination immer noch ziemlich nahe an der theoretischen Höchstgeschwindigkeit liegt, zu der SQL + C # fähig ist .

In den meisten praktischen Fällen würde der größte Teil des Overheads in einer nicht optimalen SQL-Abfrage liegen und nicht mit einer gewissen Zuordnung der Ergebnisse auf der C # -Seite.

Leistungstestergebnisse

Gesamtzahl der Iterationen: 1000

Dapper by itself: 1,889 Millisekunden pro Abfrage mit 3 lines of code to return the dynamic.
Dapper + Slapper.Automapper: 2,463 Millisekunden pro Abfrage unter Verwendung einer zusätzlichen 3 lines of code for the query + mapping from dynamic to POCO Entities.

Gearbeitetes Beispiel

In diesem Beispiel haben wir eine Liste von Contactsund jeder Contactkann eine oder mehrere haben phone numbers.