Cláusula Join

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;

Miguel Teheran

Profesor

Sirve mucho para practicar hacer el versus de Métodos de extension con Query expression

Jimmy Buriticá Londoño

#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.

Luca Cristian Manea

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

    } ```

rafael malanco velazquez

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

        }

Leonardo Valdivieso

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.

Betzabhe Elizabeth Vega Aliaga

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

Sergio Gallardo Rodríguez

Buen día.

Cómo sería la sinatxis para hacer un join con tres o más colecciones.

Gracias.

Wilson Neftali Mundo Alonzo

Unicamente vas agregandolos al final de la seleccion del Join ejemplo. digamos que adicional de la fecha de publicacion del 2005 y cantidad de paginas mayor a 500 necesitas la categoria java creas una lista adicional y realizas el join al final de la ultima seleccion de p se veria asi

Joan Alexander Valerio Rodríguez

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

Cristina Alejandra Morales Oñate

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;

}

Marta Maleyka Magallón Escobar

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.

Angel Qui

Qué bendición el método de query

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

Joel Angel David Barrantes Palacios

Resumen del Curso

Click Aquí

JUAN DAVID MARTINEZ GONZALEZ

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

JOHN CARLOS ARRIETA ARRIETA