c# - metodo - Únete/Donde con LINQ y Lambda

linq lambda c# tutorial

Question

Estoy teniendo problemas con una consulta escrita en LINQ y Lambda. Hasta ahora, estoy recibiendo 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, así que no estoy seguro de si esta consulta es correcta.

Answer 1

1 es igual a 1 dos combinaciones de tablas diferentes

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

Answer 2

Creo que si está familiarizado con la sintaxis SQL, usar 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ás atascado con el uso de lambdas, tu sintaxis está un poco 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

Answer 3

Daniel tiene una buena explicación de las relaciones de sintaxis, pero puse este documento en conjunto para que mi equipo lo simplifique un poco para que lo entiendan. Espero que esto ayude a alguien

Answer 4

Esta consulta de linq debería funcionar para usted. Obtendrá todos los posts que tengan meta de 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

Answer 5

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

Answer 6

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

Answer 7

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 externas apropiadas en su base de datos (entre post y post_meta), entonces probablemente no necesite una unión explícita a menos que esté tratando de cargar una gran cantidad de registros. . Su ejemplo parece indicar que está intentando cargar una sola publicación y sus metadatos. Suponiendo que hay muchos registros post_meta para cada publicación, entonces podría hacer lo siguiente:

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

Si desea evitar el problema de n + 1, entonces puede indicar 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 carga una publicación, también cargue todos sus registros asociados a 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 realizar muchas llamadas LoadWith en un único conjunto de DataLoadOptions para el mismo tipo, o muchos tipos diferentes. Sin embargo, si haces estos lotes, tal vez solo quieras considerar el almacenamiento en caché.

Answer 8

Publicación porque cuando comencé LINQ + EntityFramework, observé estos ejemplos por un día.

Si está utilizando EntityFramework y tiene una propiedad de navegación llamada Meta en su configuración de objetos de modelo Post , esto es muy fácil. Si está usando la 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 el 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;}
}

Answer 9

Sus selectores clave son incorrectos. Deben tomar un objeto del tipo de la 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 posteriormente, no como parte del selector de teclas.