Convertir una instrucción SQL en LINQ-To-SQL

Question

puedo obtener una mano convirtiendo lo siguiente en una instrucción LINQ.

SELECT reports.* FROM [dbo].[ReportLists] rl 
INNER JOIN [dbo].[ReportItems] ri ON rl.Id = ri.ReportListId 
INNER JOIN [dbo].[Reports] reports ON ri.Id = reports.ReportItemId 
WHERE 
    reports.createdDate 
IN (
    SELECT 
     MAX(report_max_dates.createdDate) 
    FROM 
     [dbo].[Reports] report_max_dates 
    GROUP BY 
     report_max_dates.seedLot 
    ) 

En este momento tengo que reduce a esto:

db.ReportLists.Select(rl => db.ReportItems 
          .Where(ri => ri.ReportListId == rl.Id) 
          .Select(ri => db.Reports 
              .Where(r => r.ReportItemId == ri.Id) 
              .GroupBy(r => new { r.seedLot }) 
              .Select(g => g.OrderByDescending(x => x.createdDate).FirstOrDefault()))); 

El problema con el anterior es LINQ que devuelve las entradas que tienen títulos cambiados. Dentro de la base de datos guardo el historial de todos los registros (de ahí la necesidad de que el primero en el orden creado Fecha de descenso. Cuando cambio un informe del título x al título y, aparece en ambos títulos cuando solo quiero el registro más reciente que por lo tanto, ser el que, bajo el título y.

eDITAR lo siento por la falta de detalles. tengo una tabla informes que contiene información sobre el informe (lote de semillas de ser un identificador). Siempre que un informe es editado, un nuevo récord se inserta (frente a la actualización del anterior) para que se guarde el historial. En este caso, la entrada máxima para el Fecha de creación indica que el informe es el registro más reciente que se mostrará. Los informes se agrupan en títulos o Artículos de informe. mantenga el título y los informes asociados. Estos artículos de informe se guardan en una Lista de en I puede imprimir el JSON en un formato deseado y solo contiene una columna de estado y una identificación vinculadas por ReportItems.

En el caso de que un informe se traslade del título a al título b, se ingresa un nuevo registro con la clave externa del título que enlaza con el título al que se cambió. Cuando esto sucede, el LINQ indicado anteriormente devuelve el registro en cada ReportItem individual cuando solo debe devolver la entrada más nueva para el título b (del ejemplo anterior). Aparte de esto, la instrucción LINQ solo devuelve el registro más reciente para createdDate.

Éstos son mis estructuras de clase (que imitan la estructura DB así)

public class ReportList { 
    public int Id {get;set;} 
    public string status {get;set;} 
    public List<ReportItem> {get;set;} 
} 

public class ReportItem { 
    public int Id {get;set} 
    public string title {get;set;} 
    public List<Report> {get;set;} 
} 

public class Report { 
    public int Id {get;set;} 
    public string Lot {get;set;} 
    ... Other data ... 
    public DateTime createdDate {get;set;} 
} 

Gracias, Dman

Answer 1

Cambié el esquema de la base de datos para aplastarlo un poco y sacar una gran parte de la bifurcación.

El informe ahora es la raíz y solo tengo una tabla de títulos que se adjuntan a los informes.

Gracias a todos por las sugerencias tho!

Answer 2

Si he entendido bien, entonces usted quiere último informe de lote de semillas, entonces yo' d uso siguiente:

from r in Reports 
group r by r.CreateDate into g 
select g.OrderByDescending(r1=>r1.CreateDate).FirstOrDefault() 

no estoy seguro de por qué se necesita ReportItem y ReportList si no incluirlos en consecuencia, por la que se puede recorrer a ellos con Propiedades de navegación del informe.

Answer 3

Ah. Ya veo. Su unión interna está eliminando aquellos registros que no tienen identificador en la tabla de artículos de informe y artículos de informe que no tienen Id en la tabla de listas de informes. Como no está utilizando la sintaxis de unión interna en Linq, no son equivalentes. ¿Has probado esto:

var reports = from rl in db.ReportLists 
       from ri in rl.ReportItems 
       from r in ri.Reports 
       where (
        from report in db.Reports 
        group report by report.seedLot into g 
        select g.Max(rep => rep.createdDate)).Contains(r.CreatedDate) 
       select rl; 

No estoy 100% que tengo el derecho de sintaxis en ese grupo con Contiene (no hago un montón de agrupar día a día). Y si el proveedor de LINQ no es compatible con Max (o Contiene, aunque debería), obtendrá todo del lado del cliente y esa es una gran cantidad de datos para enviar por el cable.

Answer 4

Los detalles que proporciona lo hacen mucho más claro, aunque no del todo, así que le daré dos alternativas.Las propiedades de navegación son muy útiles, como la sintaxis completa ahora muy concisa es posible:

from rl in context.ReportLists 
from ri in rl.ReportItems 
from r in ri.Reports 
group r by r.Lot into g 
select g.OrderByDescending(x => x.createdDate).FirstOrDefault() 

o (ya que parece que el grupo de Title en ReportItems):

from rl in context.ReportLists 
from ri in rl.ReportItems 
group ri by ri.Title into g 
select g.Select(x => x.Reports 
         .OrderByDescending(x => x.createdDate).FirstOrDefault()) 

bajo el capó esto también produce SQL se une, pero no necesita la sintaxis incómoda. En la sintaxis fluida de linq se reduce a SelectMany() s.

Como ve, todavía no puedo entender el papel de Lot y Title, pero espero que las alternativas le den cierta sustancia al molde según sus propias especificaciones.