Come scrivere questo LINQ SQL come una query dinamica (utilizzando stringhe)?

Question

Vai alla "questione specifica", se necessario. Alcuni retroscena:

Lo scenario: Ho una serie di prodotti con un "drill-down" del filtro (Object Query) popolato da DDL. Ogni selezione progressiva DDL limiterà ulteriormente l'elenco dei prodotti e quali opzioni sono a sinistra per il DDL. Ad esempio, selezionando un martello di strumenti limita le dimensioni del prodotto ai soli formati spettacolo martello.

Impostazione corrente: Ho generato un oggetto query, inviato ad un repository, ed alimentato ogni opzione per uno SQL "tabella funzioni valutata" in cui i valori nulli rappresentano "ottenere tutti i prodotti"

considero questo un buon sforzo, ma lontano da DDD accettabile. Voglio evitare qualsiasi "programmazione" in SQL, si spera fare tutto con un repository. Commenti su questo tema sarebbe apprezzato.

Domanda specifica:

Come faccio a riscrivere questa query come un Query dinamica ? Un link a qualcosa di simile a 101 Esempi Linq sarebbe fantastico, ma con un ambito Query dinamica. Ho molta voglia di passare a questo metodo il campo tra virgolette "" per il quale voglio un elenco di opzioni e quanti prodotti hanno questa opzione.

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

Ogni opzione DDL avrà "La selezione (21)" dove il (21) è la quantità di prodotti che hanno quell'attributo. Dopo aver selezionato l'opzione, tutte le altre DDL rimanenti verranno aggiornati con le restanti opzioni e conteggi.

Modifica: Note aggiuntive:

.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

Quello che ho imparato finora è LINQPad è fantastico, ma ancora alla ricerca di una risposta. Alla fine, la ricerca del tutto casuale come questo prevarrà immagino. LOL.

Modifica

Jon Skeet ha avuto un'idea fantastica: scaccio quello che mi serve come IGrouping<string, Product>. Grazie a Jon Skeet! Una volta che il cast dell'oggetto, è possibile enumerare nel corso degli insiemi e dei mangimi i risultati in un elenco a parte.

Answer 1

Non sono sicuro di come fare questa sintassi Query utilizzando (come sopra), ma utilizzando la sintassi metodo, possiamo usare un'espressione

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

Se si dà un'occhiata a C # Bits , l'autore discute come creare filtri in cascata utilizzando Dynamic Data. Non suona come si sta utilizzando Dynamic Data, ma lui ha un bel generatore di espressioni che potrebbe essere utile a voi. Vedere BuildQueryBody, e quindi la seguente sezione di metodi di estensione su IQueryable.

Dal momento che non si utilizza Dynamic Data, è necessario affrontare non avere accesso a un oggetto "MetaForeignKeyColumn", ma ho il sospetto il suo approccio potrebbe aiutare con la vostra domanda.

Spero che questo aiuta.