Comment calculer efficacement des produits cartésiens dans LINQ avec un nombre d'ensembles inconnu ?

Produit cartésien dans LINQ

Dans le domaine du traitement des données, le produit cartésien est une opération de base qui combine des éléments de plusieurs ensembles pour créer de nouvelles combinaisons. Cet article explore une approche basée sur LINQ pour implémenter des produits cartésiens, en particulier pour les situations où le nombre de collections est inconnu au moment de la compilation.

Comprendre le produit cartésien

En termes simples, le produit cartésien combine chaque élément d'un ensemble avec chaque élément de l'autre ensemble, générant toutes les associations possibles. Considérons un ensemble de personnes {p1, p2, p3} et un ensemble de chiens {d1, d2, d3}. Le produit cartésien de ces deux ensembles sera :

<code>{(p1, d1), (p1, d2), (p1, d3),
 (p2, d1), (p2, d2), (p2, d3),
 (p3, d1), (p3, d2), (p3, d3)}</code>

Implémentation LINQ

Afin d'exécuter un produit cartésien dans LINQ, nous pouvons utiliser l'opérateur SelectMany. Cependant, lorsque le nombre de collections est inconnu au moment de la compilation, nous avons besoin d'une approche plus flexible. C'est là qu'intervient la méthode CartesianProduct :

<code>public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> sequences)
{
    // 基本情况：空序列
    if (!sequences.Any())
        return new[] { Enumerable.Empty<T>() };

    // 简化为两个序列
    var first = sequences.First();
    var rest = sequences.Skip(1);

    // 递归计算其余部分的笛卡尔积
    var cartesianProducts = rest.CartesianProduct();

    // 将第一个序列与每个笛卡尔积组合
    return from f in first
           from c in cartesianProducts
           select f.Concat(c);
}</code>

Exemple d'utilisation

Considérons notre exemple précédent d'une personne avec trois chiens, chacun avec un nombre différent de chiots :

<code>Person person = ...;
var puppyCombinations = CartesianProduct(from dog in person.Dogs select dog.Puppies);</code>

Ce code générera toutes les combinaisons possibles de chiots pour chaque chien, similaire à la requête SQL mentionnée dans la question :

<code>{(puppyA, puppyA),
 (puppyA, puppyB),
 (puppyB, puppyA),
 (puppyB, puppyB)}</code>

Conclusion

En utilisant la méthode CartesianProduct, nous pouvons calculer les produits cartésiens dans LINQ de manière flexible et efficace, même lorsque le nombre de collections est inconnu au moment de la compilation. Cela ouvre des possibilités pour une variété de tâches de traitement et de combinaison de données.

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!