Ich verstehe Dappers Mapping, Multimapping und QueryMultiple nicht

Ich denke, dass Ihr Hauptproblem bei der Dapper-Abfrage verknüpfter Tabellenabfragen darin besteht, dass das zweite Argument in der Liste immer das Argument "param" ist. Betrachten Sie den folgenden Code:

var productsWithoutCategories = conn.Query<Product>(
    "SELECT * FROM Products WHERE ProductName LIKE @nameStartsWith + '%'",
    new { nameStartsWith = "a" }
);

Hier gibt es zwei Argumente "sql" und "param" - wenn wir benannte Argumente verwenden, würde der Code wie folgt aussehen:

var productsWithoutCategories = conn.Query<Product>(
    sql: "SELECT * FROM Products WHERE ProductName LIKE @nameStartsWith + '%'",
    param: new { nameStartsWith = "a" }
);

In Ihrem Beispiel haben Sie

var data = connection.Query<Post, User, Post>(sql, (post, user) => { post.Owner = user; return post;});

Das zweite Argument dort ist eigentlich ein Argument namens "map", das Dapper sagt, wie man Entitäten für Fälle kombiniert, in denen Sie zwei Tabellen in Ihrer SQL-Abfrage verbunden haben. Wenn wir benannte Argumente verwenden würden, würde es so aussehen:

var data = connection.Query<Post, User, Post>(
    sql: sql,
    map: (post, user) => { post.Owner = user; return post;}
);

Ich werde die Klasse NORTHWND- Datenbank in einem vollständigen Beispiel verwenden. Sagen wir, wir haben die Klassen

public class Product
{
    public int ProductId { get; set; }
    public string ProductName { get; set; }
    public bool Discontinued { get; set; }
    public Category Category { get; set; }
}

public class Category
{
    public int CategoryID { get; set; }
    public string CategoryName { get; set; }
}

und wir möchten eine Liste von Produkten erstellen, wobei der Typ der verschachtelten Kategorie ausgefüllt wird:

using (var conn = new SqlConnection("Server=.;Database=NORTHWND;Trusted_Connection=True;"))
{
    var productsWithCategories = conn.Query<Product, Category, Product>(
        "SELECT * FROM Products INNER JOIN Categories ON Categories.CategoryID = Products.CategoryID,
        map: (product, category) =>
        {
            product.Category = category;
            return product;
        },
        splitOn: "CategoryID"
    );
}

Dies durchläuft alle Zeilen von JOIN'd Product- und Category-Daten und generiert eine Liste eindeutiger Produkte, kann jedoch nicht sicher sein, wie die Category-Daten damit kombiniert werden. Daher ist eine "map" -Funktion erforderlich, die eine Product-Instanz und Eine Category-Instanz, die eine Product-Instanz zurückgeben muss, mit der die Category-Daten verknüpft sind. In diesem Beispiel ist es einfach - wir müssen lediglich die Category-Eigenschaft für die Product-Instanz auf die Category-Instanz festlegen.

Beachten Sie, dass ich einen "splitOn" -Wert angeben musste. Dapper geht davon aus, dass die Schlüsselspalten der Tabellen einfach als "Id" bezeichnet werden, und wenn dies der Fall ist, kann sie automatisch mit Joins dieser Spalten umgehen. In diesem Fall fügen wir jedoch eine Spalte mit dem Namen "CategoryID" hinzu, und daher müssen wir Dapper mitteilen, dass die Daten entsprechend dem Spaltennamen in Produkte und Kategorien aufgeteilt werden sollen.

Wenn wir auch "param" -Objekt angeben möchten, um die Ergebnisse herunterzufiltern, könnten wir Folgendes tun:

var productsWithCategories = conn.Query<Product, Category, Product>(
    "SELECT * FROM Products INNER JOIN Categories ON Categories.CategoryID = Products.CategoryID WHERE ProductName LIKE @nameStartsWith + '%'",
    map: (product, category) =>
    {
        product.Category = category;
        return product;
    },
    param: new { nameStartsWith = "a" },
    splitOn: "CategoryID"
);

Um Ihre letzte Frage zu beantworten, führt QueryMultiple einfach mehrere Abfragen auf einmal aus und ermöglicht Ihnen dann, sie separat zu lesen. Zum Beispiel, anstatt dies zu tun (mit zwei getrennten Abfragen):

using (var conn = new SqlConnection("Server=.;Database=NORTHWND;Trusted_Connection=True;"))
{
    var categories = conn.Query("SELECT * FROM Categories");
    var products = conn.Query("SELECT * FROM Products");
}

Sie können eine einzelne SQL-Anweisung angeben, die beide Abfragen in einem Stapel enthält. Sie müssen sie dann jedoch separat aus dem kombinierten Ergebnissatz lesen, der von QueryMultiple zurückgegeben wird:

using (var conn = new SqlConnection("Server=.;Database=NORTHWND;Trusted_Connection=True;"))
{
    var combinedResults = conn.QueryMultiple("SELECT * FROM Categories; SELECT * FROM Products");
    var categories = combinedResults.Read<Category>();
    var products = combinedResults.Read<Product>();
}

Ich denke, dass die anderen Beispiele, die ich von QueryMultiple gesehen habe, ein wenig verwirrend sind, da sie oft einzelne Werte von jeder Abfrage zurückgeben, anstatt vollständige Sätze von Reihen (was in einfachen Abfrageaufrufen häufiger zu sehen ist). Hoffentlich macht das obige das für Sie klar.

Hinweis: Ich habe Ihre Frage zum Attribut [Tabelle] nicht beantwortet. Wenn Sie nach dem Ausprobieren immer noch Probleme haben, würde ich vorschlagen, eine neue Frage zu erstellen. Dapper verwendet den "splitOn" -Wert, um zu entscheiden, wann die Spalten für eine Entität enden und den nächsten Start (im obigen JOIN-Beispiel gab es Felder für Product und dann Felder für Category). Wenn Sie die Category-Klasse in etwas anderes umbenannt haben, dann funktioniert die Abfrage immer noch, Dapper verlässt sich in diesem Fall nicht auf den Tabellennamen - hoffentlich brauchen Sie die [Table] also gar nicht.