Unirse / Dónde con LINQ y Lambda

Usted podría 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 las dos dependiendo de cuál es más fácil de leer).

Lo que me gustaría señalar sin embargo es que si usted tiene claves foráneas apropiadas en su base de datos, (entre post y post_meta) entonces probablemente no necesita una unirse explícitamente a menos que esté tratando de cargar un gran número de registros. Tu ejemplo parece indicar que estás tratando de cargar un solo post y son metadatos. Suponiendo que hay muchos registros post_meta para cada post, entonces usted podría hacer lo siguiente:

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

Si desea evitar el problema n+1, entonces puede decirle explícitamente a LINQ to SQL que cargue todos los elementos relacionados de una sola vez (aunque este puede ser un tema avanzado para cuando esté más familiarizado con L2S). El siguiente ejemplo dice"cuando cargue un Post, también cargue todos sus registros asociados a él a través de la clave foránea 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 llamadas LoadWith en un solo conjunto de DataLoadOptions para el mismo tipo, o muchos tipos diferentes. Sin embargo, si haces esto mucho, es posible que solo quieras considerar el almacenamiento en caché.

Sus selectores de teclas son incorrectos. Deben tomar un objeto del tipo de la tabla en cuestión y devolver la clave a usar en la combinació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.

Daniel tiene una buena explicación de las relaciones de sintaxis, pero armé este documento para mi equipo con el fin de que sea un poco más fácil de entender para ellos. Espero que esto ayude a alguien

Publicando porque cuando empecé LINQ + EntityFramework, observé estos ejemplos durante un día.

Si está utilizando EntityFramework, y tiene una propiedad de navegación llamada Meta en su objeto de modelo Post configurado, esto es muy fácil. Si estás usando entity y no tienes esa propiedad de navegación, ¿qué estás esperando?

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

Si estás haciendo el código primero, configurarías 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};

Esta consulta linq debería funcionar para usted. Obtendrá todo el post que tiene meta post.

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

1 es igual a 1 dos tablas diferentes unirse

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 };