linq - tipos - Entity Framework 4-¿Cuál es la sintaxis para unir 2 tablas y luego buscarlas?

test linq query

Question

NO es una pregunta duplicada

Me doy cuenta de que hay otra pregunta en Entityframework Join using join method y lambdas que alguien marcó incorrectamente esto como un duplicado. Mi pregunta es específicamente sobre paginación de una tabla basada en una tabla relacionada, como lo indica el título. La otra pregunta es sobre la unión de tablas, pero no tiene absolutamente nada que ver con la paginación (ni hay respuestas de paginación).

Ya sabía cómo hacer una unión LINQ antes de hacer la pregunta (de hecho, en mi pregunta original a continuación hay un ejemplo). Simplemente no pude resolver la sintaxis de la paginación. Han pasado varios años desde que publiqué esto y no recuerdo si encontré la respuesta vinculada cuando busqué, pero puedo ver que no habría sido útil en absoluto para lo que estaba tratando de lograr.

Incluso expresé específicamente en mi pregunta original que si hay una alternativa mejor que utilizar una combinación de tablas, la aceptaría como una respuesta .

Tengo la siguiente consulta de linq-a-entidades con 2 tablas unidas a las que me gustaría añadir paginación:

IQueryable<ProductInventory> data = from inventory in objContext.ProductInventory
    join variant in objContext.Variants
        on inventory.VariantId equals variant.id
     where inventory.ProductId == productId
     where inventory.StoreId == storeId
     orderby variant.SortOrder
     select inventory;

Me doy cuenta de que necesito usar el método de extensión .Join () y luego invoco .OrderBy (). Skip (). Take () para hacer esto, solo estoy tropezando con la sintaxis de Join () y no puedo para encontrar ejemplos (ya sea en línea o en libros).

NOTA: El motivo por el que me uno a las tablas es para hacer la clasificación. Si hay una forma mejor de ordenar en función de un valor en una tabla relacionada que unirse, por favor inclúyalo en su respuesta.

2 posibles soluciones

Supongo que este es solo cuestión de legibilidad, pero ambos funcionarán y son semánticamente idénticos.

1

IQueryable<ProductInventory> data = objContext.ProductInventory
                .Where(y => y.ProductId == productId)
                .Where(y => y.StoreId == storeId)
                .Join(objContext.Variants,
                    pi => pi.VariantId,
                    v => v.id,
                    (pi, v) => new { Inventory = pi, Variant = v })
                .OrderBy(y => y.Variant.SortOrder)
                .Skip(skip)
                .Take(take)
                .Select(x => x.Inventory);

2

var query = from inventory in objContext.ProductInventory
    where inventory.ProductId == productId
    where inventory.StoreId == storeId
    join variant in objContext.Variants
        on inventory.VariantId equals variant.id
    orderby variant.SortOrder
    select inventory;

var paged = query.Skip(skip).Take(take);

Felicitaciones a Khumesh y Pravin por ayudar con esto. Gracias al resto por contribuir.

Answer 1

Agregue la siguiente línea a su consulta

var pagedQuery = data.Skip(PageIndex * PageSize).Take(PageSize); 

La variable de datos es IQueryable, por lo que puedes poner el método add skip & take en él. Y si tienes una relación entre el producto y la variante, realmente no necesitas unirte explícitamente, puedes referir la variante a algo como esto

IQueryable<ProductInventory> data = 
             from inventory in objContext.ProductInventory
             where inventory.ProductId == productId && inventory.StoreId == storeId
             orderby inventory.variant.SortOrder
             select new()
             {
                 property1 = inventory.Variant.VariantId,
                 //rest of the properties go here
             }
pagedQuery = data.Skip(PageIndex * PageSize).Take(PageSize); 

Answer 2

Defina la unión en su mapeo y luego úselo. Realmente no obtienes nada mediante el método Join ; en su lugar, utiliza el método Include . Es mucho mejor.

var data = objContext.ProductInventory.Include("Variant")
               .Where(i => i.ProductId == productId && i.StoreId == storeId)
               .OrderBy(j => j.Variant.SortOrder)
               .Skip(x)
               .Take(y);

Answer 3

Mi respuesta aquí se basa en la respuesta que está marcada como verdadera, pero aquí agrego una nueva mejor práctica del código anterior

    var data= (from c in db.Categorie.AsQueryable().Join(db.CategoryMap,
                    cat=> cat.CategoryId, catmap => catmap.ChildCategoryId, 
    cat, catmap) => new { Category = cat, CategoryMap = catmap })
select (c => c.Category)

esta es la mejor práctica para usar el Linq a la entidad porque cuando agregas AsQueryable () a tu código; sistema convertirá un System.Collections.Generic.IEnumerable genérico a un System.Linq.IQueryable genérico que es mejor para el motor .Net para construir esta consulta en tiempo de ejecución

gracias Sr. Khumesh Kumawat

Answer 4

Simplemente usaría su salto (ItemsInPage * pageNo) .Take (ItemsInPage) para hacer paging.