Comment LINQ peut-il générer efficacement des produits cartésiens à partir de relations d'objets à plusieurs niveaux ?

Générer efficacement des produits cartésiens à partir de relations d'objets multi-niveaux avec LINQ

La programmation orientée objet implique souvent des relations complexes à plusieurs niveaux. Prenons cet exemple :

<code class="language-csharp">class Person {
    public List<Dog> Dogs { get; set; }
}

class Dog {
    public List<Puppy> Puppies { get; set; }
}

class Puppy {
    public string Name { get; set; }
}</code>

Ici, un Person a plusieurs Dog, et chaque Dog a plusieurs Puppy. Le défi est de générer le produit cartésien : toutes les combinaisons possibles en sélectionnant un Puppy dans chaque Dog.

Le SQL traditionnel utiliserait des jointures. LINQ propose une solution plus élégante. Pour un nombre fixe de Dog (connu au moment de la compilation), une simple requête LINQ suffit :

<code class="language-csharp">from p1 in dog1.Puppies
from p2 in dog2.Puppies
from p3 in dog3.Puppies
select new { p1, p2, p3 };</code>

Cela donne des combinaisons telles que :

<code>{p11, p21, p31},
{p11, p21, p32},
{p12, p21, p31},
{p12, p21, p32}</code>

Cependant, lorsque le nombre de Dogs est dynamique (inconnu au moment de la compilation), une approche plus généralisée est nécessaire. L'article d'Eric Lippert (https://www.php.cn/link/f28c49d8be62973ac7716e0b87dae2f9) propose une solution robuste pour ce scénario.

Avec une méthode CartesianProduct appropriée (telle que décrite dans l'article de Lippert), la requête se simplifie en :

<code class="language-csharp">CartesianProduct(from dog in person.Dogs select dog.Puppies);</code>

Cela permet d'obtenir le même résultat. La puissance expressive de LINQ permet une gestion concise et maintenable de relations d'objets complexes à plusieurs niveaux, simplifiant ainsi la création de produits cartésiens.

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!