No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Cláusula Join

25/26
Recursos

Aportes 14

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Utilizando query expression

var result = from booksAfter2005 in books 
                 join booksPublishedAfter2005 in books
                 on booksAfter2005.Title equals booksPublishedAfter2005.Title
                 where booksAfter2005.PageCount >= 500 && booksPublishedAfter2005.PublishedDate.Year > 2005
                 select booksAfter2005;

#Cláusula Join
Al igual que en SQL tenemos en Linq un operador que nos permite interceptar dos colecciones y devolver los elementos que se encuentran en ambas colecciones.

Ejemplo simple con subquerys

    public IEnumerable<Book>BooksAfter2005AndPagesGreaterThan500(IEnumerable<Book> books){

        return ( from x in (from b in books where b.PublishedDate.Year>=2005 select b) join 
        y in (from book in books where book.PageCount>500 select book) on x.Title equals y.Title
        select x);   

    } ```
 public IEnumerable<Book> LibrosConMasDe500PaginasYPublicadosDespuesDel2005()
        {
            // extension method
            // return librosCollection.Where(book => book.PageCount > 500).Join(librosCollection.Where(book => book.PublishedDate.Year > 2005), book => book.Id, book => book.Id, (book1, book2) => book1);
            // query method
            return (from book in librosCollection
                    where book.PageCount > 500
                    join book2 in librosCollection
                    on book.Title equals book2.Title
                    where book2.PublishedDate.Year > 2005
                    select book);

        }
```js public IEnumerable<Book> librosconmasde500pagpub2005() { var colection = librosCollection.Where(p => p.PublishedDate.Year > 2005); var resultado = librosCollection .Where(p => p.PageCount > 500) .Join(colection, p => p.Title, x => x.Title, (p, x) => p); return resultado; } ```public *IEnumerable*\<Book> librosconmasde500pagpub2005()    {        var colection = librosCollection.Where(*p* => *p*.PublishedDate.Year > 2005);        var resultado = librosCollection            .Where(*p* => *p*.PageCount > 500)            .Join(colection,                *p* => *p*.Title,                *x* => *x*.Title,                (*p*, *x*) => *p*);         return resultado;     }

Entonces el Join es para juntar dos tablas que están relacionadas por un ID. Faltó ver el Left Join y el Right Join que existen en SQL junto con una posible relación ternaria.

```txt //Extension Method var pageCountDownCollection = BooksCollections.Where(p => p.PageCount > 500); var publishedDateCollection = BooksCollections.Where(p => p.PublishedDate.Year > 2005); return pageCountDownCollection .Join(publishedDateCollection, p => p.Title, x => x.Title, (p, x) => p); //Query Expression var pageQuery = from p in BooksCollections where p.PageCount > 500 select p; var dateQuery = from d in BooksCollections where d.PublishedDate.Year > 2005 select d; var query = pageQuery.Join(dateQuery, p => p.Title, x => x.Title, (p, x) => p); return query; ```
Buen día. Cómo sería la sinatxis para hacer un join con tres o más colecciones. Gracias.
public IEnumerable\<Book> JoinBooks() { var booksWithMore500 = booksCollection.Where(w=> w.PageCount > 500); var booksPublish2005 = booksCollection.Where(w => w.PublishedDate.Year > 2005); var books = from book500 in booksWithMore500 join bookPublish2005 in booksPublish2005 on book500.Title equals bookPublish2005.Title select book500; return books; }
En resumen, el operador `join` en LINQ es una herramienta poderosa para combinar datos de múltiples fuentes basadas en una condición de igualdad entre las claves de las colecciones. Esto facilita la creación de consultas que relacionan datos de diferentes partes de una aplicación.
Qué bendición el método de query ```js public IEnumerable<Book> JoinMomento() { // extension method /* return LibrosConXMasPaginas(500) .Join(LibrosDespuesDeXFecha(2005), p => p.Title, x => x.Title, (p,x) => p); */ // query method return from f in LibrosDespuesDeXFecha(2005) join p in LibrosConXMasPaginas(500) on f.Title equals p.Title select p; } ```

Resumen del Curso

Click Aquí

public IEnumerable<Book> LibrosDespues2005PaginasMasd500()
    {
        //  Extension Method
       // var librosDespuesDel2005 = librosCollection.Where(x => x.PublishedDate.Year > 2005);

       // var LibrosMasDe500Pag = librosCollection.Where(y => y.PageCount > 500);

       // return librosDespuesDel2005.Join(LibrosMasDe500Pag, x => x.Title, y => y.Title, (x,y) => x);

         //---->> Extension Query <<------
        var result = from list1 
                     in librosCollection
                     join list2
                     in librosCollection
                     on list1.Title equals list2.Title
                     where list1.PublishedDate.Year > 2005 && list2.PageCount > 500
                     select list1;

        return result;
    }

**EXPRESION DE CONSULTA **

var librosUnidos = from l1 in bd.ListaDeLibros() 
                   join l2 in bd.ListaDeLibros() 
                   on l1.Title equals l2.Title
                   where l1.PageCount > 500 &&
                            l2.PublishedDate.Year > 2005
                   select l1;

SINTAXIS DE METODOS

librosUnidos = bd.ListaDeLibros()
    .Where(book => book.PageCount > 500)
        .Join(
            bd.ListaDeLibros()
                .Where(
                    (book => book.PublishedDate.Year > 2005))
                    , b1 => b1.Title, b2 => b2.Title
                    , (b1, b2) => b1);