Únete / Dónde con LINQ y Lambda

Tengo problemas con una consulta escrita en LINQ y Lambda. Hasta ahora, recibo muchos errores aquí está mi código:

int id = 1;
var query = database.Posts.Join(database.Post_Metas,
                                post => database.Posts.Where(x => x.ID == id),
                                meta => database.Post_Metas.Where(x => x.Post_ID == id),
                                (post, meta) => new { Post = post, Meta = meta });

Soy nuevo en el uso de LINQ, por lo que no estoy seguro de si esta consulta es correcta.

Creo que si está familiarizado con la sintaxis SQL, el uso de la sintaxis de consulta LINQ es mucho más claro, más natural y facilita la detección de errores:

var id = 1;
var query =
   from post in database.Posts
   join meta in database.Post_Metas on post.ID equals meta.Post_ID
   where post.ID == id
   select new { Post = post, Meta = meta };

Sin embargo, si realmente está atascado en el uso de lambdas, su sintaxis está bastante apagada. Aquí está la misma consulta, utilizando los métodos de extensión LINQ:

var id = 1;
var query = database.Posts    // your starting point - table in the "from" statement
   .Join(database.Post_Metas, // the source table of the inner join
      post => post.ID,        // Select the primary key (the first part of the "on" clause in an sql "join" statement)
      meta => meta.Post_ID,   // Select the foreign key (the second part of the "on" clause)
      (post, meta) => new { Post = post, Meta = meta }) // selection
   .Where(postAndMeta => postAndMeta.Post.ID == id);    // where statement

Podrías ir de dos maneras con esto. Usando LINQPad (invaluable si eres nuevo en LINQ) y una base de datos ficticia, construí las siguientes consultas:

Posts.Join(
    Post_metas,
    post => post.Post_id,
    meta => meta.Post_id,
    (post, meta) => new { Post = post, Meta = meta }
)

o

from p in Posts
join pm in Post_metas on p.Post_id equals pm.Post_id
select new { Post = p, Meta = pm }

En este caso particular, creo que la sintaxis de LINQ es más limpia (cambio entre los dos dependiendo de cuál sea más fácil de leer).

Sin embargo, lo que me gustaría señalar es que si tiene claves foráneas apropiadas en su base de datos (entre post y post_meta), probablemente no necesite una unión explícita a menos que esté intentando cargar una gran cantidad de registros . Su ejemplo parece indicar que está intentando cargar una sola publicación y son metadatos. Suponiendo que hay muchos registros post_meta para cada publicación, puede hacer lo siguiente:

var post = Posts.Single(p => p.ID == 1);
var metas = post.Post_metas.ToList();

Si desea evitar el problema n + 1, puede decirle explícitamente a LINQ to SQL que cargue todos los elementos relacionados de una vez (aunque este puede ser un tema avanzado para cuando esté más familiarizado con L2S). El siguiente ejemplo dice "cuando cargue una publicación, también cargue todos sus registros asociados con ella a través de la clave externa representada por la propiedad 'Post_metas'":

var dataLoadOptions = new DataLoadOptions();
dataLoadOptions.LoadWith<Post>(p => p.Post_metas);

var dataContext = new MyDataContext();
dataContext.LoadOptions = dataLoadOptions;

var post = Posts.Single(p => p.ID == 1); // Post_metas loaded automagically

Es posible hacer muchas LoadWithllamadas en un solo conjunto DataLoadOptionspara el mismo tipo, o muchos tipos diferentes. Sin embargo, si hace esto mucho, es posible que desee considerar el almacenamiento en caché.

Daniel tiene una buena explicación de las relaciones de sintaxis, pero preparé este documento para mi equipo para que sea un poco más sencillo de entender. Espero que esto ayude a alguien

Sus selectores clave son incorrectos. Deben tomar un objeto del tipo de tabla en cuestión y devolver la clave para usar en la unión. Creo que te refieres a esto:

var query = database.Posts.Join(database.Post_Metas,
                                post => post.ID,
                                meta => meta.Post_ID,
                                (post, meta) => new { Post = post, Meta = meta });

Puede aplicar la cláusula where después, no como parte del selector de teclas.

Publicando porque cuando comencé LINQ + EntityFramework, miré estos ejemplos por un día.

Si está utilizando EntityFramework, y tiene una propiedad de navegación nombrada Metaen su Postobjeto modelo configurado, esto es muy fácil. Si está utilizando una entidad y no tiene esa propiedad de navegación, ¿qué está esperando?

database
  .Posts
  .Where(post => post.ID == id)
  .Select(post => new { post, post.Meta });

Si está haciendo código primero, configuraría la propiedad de esta manera:

class Post {
  [Key]
  public int ID {get; set}
  public int MetaID { get; set; }
  public virtual Meta Meta {get; set;}
}

He hecho algo como esto;

var certificationClass = _db.INDIVIDUALLICENSEs
    .Join(_db.INDLICENSECLAsses,
        IL => IL.LICENSE_CLASS,
        ILC => ILC.NAME,
        (IL, ILC) => new { INDIVIDUALLICENSE = IL, INDLICENSECLAsse = ILC })
    .Where(o => 
        o.INDIVIDUALLICENSE.GLOBALENTITYID == "ABC" &&
        o.INDIVIDUALLICENSE.LICENSE_TYPE == "ABC")
    .Select(t => new
        {
            value = t.PSP_INDLICENSECLAsse.ID,
            name = t.PSP_INDIVIDUALLICENSE.LICENSE_CLASS,                
        })
    .OrderBy(x => x.name);

Podría ser algo como

var myvar = from a in context.MyEntity
            join b in context.MyEntity2 on a.key equals b.key
            select new { prop1 = a.prop1, prop2= b.prop1};

1 es igual a 1 dos tablas diferentes se unen

var query = from post in database.Posts
            join meta in database.Post_Metas on 1 equals 1
            where post.ID == id
            select new { Post = post, Meta = meta };

Esta consulta linq debería funcionar para usted. Obtendrá todas las publicaciones que tengan meta meta.

var query = database.Posts.Join(database.Post_Metas,
                                post => post.postId, // Primary Key
                                meta => meat.postId, // Foreign Key
                                (post, meta) => new { Post = post, Meta = meta });

Consulta SQL equivalente

Select * FROM Posts P
INNER JOIN Post_Metas pm ON pm.postId=p.postId