Comment écrire cette Linq SQL comme une requête dynamique (en utilisant des chaînes)?

Question

Aller à la « question spécifique » au besoin. Un peu d'histoire:

Le scénario: J'ai un ensemble de produits avec un filtre "drill down" (Object Query) peuplé de DDLs. Chaque progressive sélection DDL limitera davantage la liste des produits ainsi que les options sont laissées pour le DDLs. Par exemple, la sélection d'un marteau sur des outils limite les dimensions du produit uniquement des tailles de marteau spectacle.

Configuration actuelle: J'ai créé un objet de requête, envoyée à un dépôt et alimenté chaque option à une SQL « table de fonction d'une valeur » où les valeurs nulles représentent « obtenir tous les produits »

Je considère cela comme un bon effort, mais loin de DDD acceptable. Je veux éviter toute « programmation » dans SQL, espérons-faire tout avec un dépôt. Les commentaires sur ce sujet serait apprécié.

Question spécifique:

Comment puis-je réécrire cette requête comme requête dynamique ? Un lien vers quelque chose comme 101 Exemples Linq serait fantastique, mais avec un champ de requête dynamique. Je veux vraiment passer à cette méthode, le champ entre guillemets « » pour laquelle je veux une liste d'options et combien de produits ont cette option.

from   p in db.Products
group  p by p.ProductSize into g
select new Category { 
       PropertyType = g.Key,
       Count = g.Count() }

Chaque option DDL aura « La sélection (21) » où le (21) est la quantité de produits qui ont cet attribut. Lors de la sélection d'une option, tous les autres DDLs restantes seront mises à jour avec les options restantes et compte.

Modifier: Notes complémentaires:

.OrderBy("it.City") // "it" refers to the entire record
.GroupBy("City", "new(City)") // This produces a unique list of City
.Select("it.Count()") //This gives a list of counts... getting closer
.Select("key") // Selects a list of unique City
.Select("new (key, count() as string)") // +1 to me LOL.  key is a row of group
.GroupBy("new (City, Manufacturer)", "City") // New = list of fields to group by
.GroupBy("City", "new (Manufacturer, Size)") // Second parameter is a projection

Product
.Where("ProductType == @0", "Maps")
.GroupBy("new(City)", "new ( null as string)")// Projection not available later?
.Select("new (key.City, it.count() as string)")// GroupBy new makes key an object

Product
.Where("ProductType == @0", "Maps")
.GroupBy("new(City)", "new ( null as string)")// Projection not available later?
.Select("new (key.City, it as object)")// the it object is the result of GroupBy

var a = Product
        .Where("ProductType == @0", "Maps")
        .GroupBy("@0", "it", "City") // This fails to group Product at all
        .Select("new ( Key, it as Product )"); // "it" is property cast though

Ce que j'ai appris à ce jour est LINQPad est fantastique, mais toujours à la recherche d'une réponse. Finalement, la recherche complètement aléatoire comme cela prévaudra je suppose. LOL.

Modifier

Jon Skeet a eu une idée fantastique: ce que je jetai besoin que IGrouping<string, Product>. Merci à Jon Skeet! Une fois que vous lancez l'objet, vous pouvez énumérer sur les jeux et intégrer les résultats dans une liste séparée.

Answer 1

Je ne sais pas comment faire en utilisant la syntaxe de requête (comme ci-dessus), mais en utilisant la syntaxe méthode, on peut utiliser une expression

using System;
using System.Linq;
using System.Linq.Expressions;

namespace LinqResearch
{
    public class Program
    {
        [STAThread]
        static void Main()
        {
            string columnToGroupBy = "Size";

            // generate the dynamic Expression<Func<Product, string>>
            ParameterExpression p = Expression.Parameter(typeof(Product), "p");

            var selector = Expression.Lambda<Func<Product, string>>(
                Expression.Property(p, columnToGroupBy),
                p
            );

            using (LinqDataContext dataContext = new LinqDataContext())
            {
                /* using "selector" caluclated above which is automatically 
                compiled when the query runs */
                var results = dataContext
                    .Products
                    .GroupBy(selector)
                    .Select((group) => new { 
                        Key = group.Key, 
                        Count = group.Count()
                    });

                foreach(var result in results)
                    Console.WriteLine("{0}: {1}", result.Key, result.Count);
            }

            Console.ReadKey();
        }
    }
}

Answer 2

Si vous jetez un oeil à C # Bits , l'auteur explique comment créer des filtres en cascade à l'aide de données dynamiques. Il ne semble pas que vous utilisez Dynamic Data, mais il a un constructeur agréable d'expression qui pourrait être utile pour vous. Voir BuildQueryBody, puis la section suivante des méthodes d'extension sur IQueryable.

Puisque vous ne l'utilisez Dynamic Data, vous devrez faire face à ne pas avoir accès à un objet « MetaForeignKeyColumn », mais je soupçonne que son approche pourrait vous aider à votre question.

J'espère que cela aide.