Comment effectuer correctement les jointures Linq et Lambda et où les clauses?

Dépannage de Linq et Lambda JOIN / WHERE CLAUSE ERRORS

Cet exemple démontre des erreurs communes lors de l'utilisation d'expressions Linq et Lambda pour les jointures et Where clauses. Analysons l'approche défectueuse, puis présentons les solutions correctes.

Incorrect linq / lambda jointer tentative:

Le code d'extrait de code suivant illustre une implémentation incorrecte:

<code class="language-csharp">int id = 1;
var query = database.Posts.Join(
    database.Post_Metas,
    post => database.Posts.Where(x => x.ID == id),  // Incorrect:  Should select a single value, not an IQueryable
    meta => database.Post_Metas.Where(x => x.Post_ID == id), // Incorrect: Should select a single value, not an IQueryable
    (post, meta) => new { Post = post, Meta = meta }
);</code>

L'erreur réside dans les sélecteurs post et meta dans la méthode Join. Au lieu de sélectionner une seule valeur (l'ID) pour se joindre, il utilise des collections Where Clauses, renvoyant IQueryable. Join s'attend à des valeurs uniques pour la correspondance des clés.

Approches correctes:

1. Utilisation de la syntaxe de requête LINQ (plus lisible):

C'est souvent la façon la plus claire d'exprimer les jointures:

<code class="language-csharp">var id = 1;
var query =
    from post in database.Posts
    join meta in database.Post_Metas on post.ID equals meta.Post_ID
    where post.ID == id
    select new { Post = post, Meta = meta };</code>

Cette syntaxe reflète directement l'opération de jointure de base de données relationnelle, ce qui facilite la compréhension.

2. Utilisation de la syntaxe de lambda (plus concise):

Pour ceux qui préfèrent les expressions de lambda, l'implémentation correcte est la suivante:

<code class="language-csharp">var id = 1;
var query = database.Posts
    .Join(database.Post_Metas,
        post => post.ID,        // Correct: Selects the ID for joining
        meta => meta.Post_ID,   // Correct: Selects the Post_ID for joining
        (post, meta) => new { Post = post, Meta = meta })
    .Where(postAndMeta => postAndMeta.Post.ID == id); // Filters after the join</code>

Cette version utilise correctement post.ID et meta.Post_ID comme clés de jointure. La clause Where est appliquée après la jointure, filtrant les résultats en fonction du post.ID. Ceci est crucial pour le filtrage correct.

En comprenant l'utilisation correcte des clés de jointure et le placement approprié de la clause Where, les développeurs peuvent éviter les erreurs courantes et écrire des requêtes LINQ efficaces et précises.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!