Selección dinámica de datos

Clase 16 de 26 • Curso de Manejo de Datos en C# con LINQ

Mairon Andres Florez Alvarez

student•

Les comparto mi funcion generica que aprovecha el uso de funciones anonimas como parametros para filtrar, ordenar y seleccionar los datos dandole dinamismo a la implementacion. considere _librosLt como el listado de libros disponibles para consultar

    public IEnumerable<dynamic> GetCustomBook(
        Func<Book, dynamic> select,
        Func<Book, bool> where,
        Func<Book, object> order,
        int take,
        int skip = 0)
    {
        return this._librosLt
            .Where(where)
            .OrderBy(order)
            .Take(take)
            .Select(select);
    }

Y asi seria su invocacion

LinqQueries queries = new LinqQueries();

var selectCustom = queries.GetCustomBook(select: x => new Book { Title = x.Title, PageCount = x.PageCount },
                                         where: x => x.PageCount > 400,
                                         order: x => x.PublishedDate,
                                         take: 4,
                                         skip: 0);

foreach (var i in selectCustom)
    Console.WriteLine(string.Format("{0, -60} {1, 15}\n", i.Title, i.PageCount));

Mairon Andres Florez Alvarez

student•

Jimmy Buriticá Londoño

student•

Operador Select

Nos permite seleccionar campos específicos de un objeto, para mejorar el rendimiento y ahorrar espacio en memoria.

Luca Cristian Manea

student•

public List<Book> getTop3FromBooks(IEnumerable<Book> books){ return books.Take(3).Select(p=> new Book(){Title = p.Title, PageCount = p.PageCount}).ToList(); }

public class BookDTO{
    public string Title {get;set;}
    public int PageCount {get;set;}
}
public List<BookDTO> getTop3FromBooksQuery(IEnumerable<Book> books){
    return (from b in books select new BookDTO{Title = b.Title, PageCount=b.PageCount}).Take(3).ToList();
}

Sandra Valentina Rodríguez Cortés

student•

public class Item
{
 public string Title { get; set; }
 public int PageCount { get; set; }
}

public IEnumerable<Item> seleccionarTituloYNumPagDeLosPrimerosTresLibros()
    {
       return booksCollection.Take(3).Select(x=> new Item() {Title =x.Title, PageCount=x.PageCount});
    }

Joan Alexander Valerio Rodríguez

student•

A continuación les comparto lo practicado en este clase, utilizando Extension method y query expression. También quise agregar un ejercicio con un mayor nivel de dificultad, tomándo en cuenta clases pasadas.

//Extension Method
return BooksCollections
       .Take(3)
       .Select(p => new Book { Title = p.Title, PageCount = p.PageCount });
        
//Query expression
var query = (from p in BooksCollections
             select new Book { Title = p.Title, PageCount = p.PageCount })
             .Take(3);

return query;

//Mi reto
var query = (from p in BooksCollections
             where p.Title.Contains("Java")
             select new Book { Title = p.Title, PublishedDate = p.PublishedDate})
             .Take(2);
        
return query;
```Espero les ayude :D

Federico Mikolajewski

student•

public IEnumerable<Book> TresPrimerosLibros()
{
  return librosCollection.Take(3)
  .Select(p=> new Book() { Title = p.Title, PCount = p.PageCount })
}

Laura Valentina Bernate Gordillo

student•

me demoré como 2h pero pude con el reto ajajajaja

JOHN CARLOS ARRIETA ARRIETA

student•

Saludos Miguel.

Gracias por el contenido de formación, es excelente .

Esta técnica de Linq nos facilita un poco parte del trabajo de obtener los objetos DTO a nivel de vista (ViewObject) a partir de de los objetos de Dominio, por ejemplo (los Entity) y evitar usar librerías de terceros como por ejemplo AutoMapper

Aprovecho la oportunidad para saber tu opción de un tema relacionado con DTO.

Siguiendo las recomendaciones de DDD y Arquitectura limpia, y tonando como base la clase Book de tu ejemplo, imaginemos que esta clase representa una entidad de negocio, entonces, el lugar ideal seria colocarla en la capa de Dominio o ``` namespace Xyx.Domain.Entityes


++LA PREGUNTA ES:++

**¿Dónde colocarías las clases DTO **BookRequesty** **BookResponse**?

OPCIONES DE REPSUESTA: 

En la **capa transversal** o común:

namespace Xyz.Common.Dto.Requests
namespace Xyz.Common.Dto.Responses


En la **capa de Infraestructura**:

namespace Xyz.Infrastructure.Presenter.Dto.Requests
namespace Xyz…Infrastructure.Presenter.Responses


En la **capa de Dominio**:

namespace Xyx.Domain.Dto.Requests
namespace Xyx.Domain.Dto.Responses


Ojala pueda contar con tu respuesta, así tendré otra perspectiva sobre este dilema y tomar la decisión correcta.
El problema esta en que estas clases por su definición, forma y uso pueden ser candidatas a formar parte de cualquiera de esas tres capas, por su puesto, la capa de Servicio esta excluida como alternativa.

Quedo atento.

Muchas gracias por tu aportes.

Miguel Teheran

teacher•

Si la idea es crear un model para transferir datos entre las capas entonces deberia ir la capa de domain o dominio

kolab Linkear

student•

Les propongo esta solución:

Creamos una nueva clase con los datos necesarios:

Creamos la Query:

Y Mandamos a llamar:

Jonathan Harley Sabogal toro

student•

    public IEnumerable<Book> TresPrimeroLibrosDeLaColeccion()
    {
        return booksCollection.Take(3)
        .Select(p => new Item(p.Title, p.PageCount) { Title = p.Title, PageCount = p.PageCount});
    }
```    public IEnumerable\<Book> TresPrimeroLibrosDeLaColeccion()    {        return booksCollection.Take(3)        .Select(p => new Item(p.Title, p.PageCount) { Title = p.Title, PageCount = p.PageCount});    }

Betzabhe Elizabeth Vega Aliaga

student•

public IEnumerable<object> TituloNumeroPagdeTresPrimerosLibros()
    {
        var libros = librosCollection
            .OrderByDescending(p => p.PageCount)
            .Take(3)
            .Select(p => new { Title = p.Title, Paginas= p.PageCount });

        foreach (var libro in libros)
        {
            Console.WriteLine($"Título: {libro.Title}, Fecha de Publicación: {libro.Paginas}");
        }

        return libros ;
    }

Mario Andrés Orozco Sánchez

student•

public IEnumerable<Book> TresPrimerosLibros() { return (from l in librosColletion select new Book{ Title = l.Title , PageCount= l.PageCount}).Take(3) ; }

Miguel Angel Reyes Moreno

student•

Lo conseguí!:

Item.cs:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Curso_Linq
{
    internal class Item
    {
        public string? Title { get; set; }
        public int PageCount { get; set; }
    }
}

al final del LinqQueries.cs:

internal class LinqQueriesItems
    {

        private List<Item> items = new List<Item>();
        public LinqQueriesItems()
        {
            using (StreamReader reader = new StreamReader("books.json"))
            {
                string json = reader.ReadToEnd();
                this.items = System.Text.Json.JsonSerializer.Deserialize<List<Item>>(json, new System.Text.Json.JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            }
        }

        public IEnumerable<Item> PrimerosXLibros(int quantity)
        {
            return items.Take(quantity)
                .Select(book => new Item()
                {
                    Title = book.Title,
                    PageCount = book.PageCount
                });
        }
    }

en Program.cs:

LinqQueriesItems items = new();

string formatoTextoItem = "{0, -60} {1, 15}";

        void ImprimirItems(IEnumerable<Item> listaDeItems)
        {
            Console.WriteLine($"{formatoTextoItem}\n", "Titulo", "N. Paginas");
            foreach (var book in listaDeItems)
            {
                Console.WriteLine($"{formatoTextoItem}", book.Title, book.PageCount);
            }
        }

//* Primeros X libros filtadros con Select
        ImprimirItems(items.PrimerosXLibros(3));

Carlos Arturo Pimentel

student•

Esta parece una excelente oportunidad para aplicar el patrón creacional Builder

    public IEnumerable<dynamic> GetCustomBook(
        Func<Book, dynamic> select,
        Func<Book, bool> where,
        Func<Book, object> order,
        int take,
        int skip = 0)
    {
        return this._librosLt
            .Where(where)
            .OrderBy(order)
            .Take(take)
            .Select(select);
    }

LinqQueries queries = new LinqQueries();

var selectCustom = queries.GetCustomBook(select: x => new Book { Title = x.Title, PageCount = x.PageCount },
                                         where: x => x.PageCount > 400,
                                         order: x => x.PublishedDate,
                                         take: 4,
                                         skip: 0);

foreach (var i in selectCustom)
    Console.WriteLine(string.Format("{0, -60} {1, 15}\n", i.Title, i.PageCount));

public class BookDTO{
    public string Title {get;set;}
    public int PageCount {get;set;}
}
public List<BookDTO> getTop3FromBooksQuery(IEnumerable<Book> books){
    return (from b in books select new BookDTO{Title = b.Title, PageCount=b.PageCount}).Take(3).ToList();
}

public class Item
{
 public string Title { get; set; }
 public int PageCount { get; set; }
}

public IEnumerable<Item> seleccionarTituloYNumPagDeLosPrimerosTresLibros()
    {
       return booksCollection.Take(3).Select(x=> new Item() {Title =x.Title, PageCount=x.PageCount});
    }

//Extension Method
return BooksCollections
       .Take(3)
       .Select(p => new Book { Title = p.Title, PageCount = p.PageCount });
        
//Query expression
var query = (from p in BooksCollections
             select new Book { Title = p.Title, PageCount = p.PageCount })
             .Take(3);

return query;

//Mi reto
var query = (from p in BooksCollections
             where p.Title.Contains("Java")
             select new Book { Title = p.Title, PublishedDate = p.PublishedDate})
             .Take(2);
        
return query;
```Espero les ayude :D

Ojala pueda contar con tu respuesta, así tendré otra perspectiva sobre este dilema y tomar la decisión correcta.
El problema esta en que estas clases por su definición, forma y uso pueden ser candidatas a formar parte de cualquiera de esas tres capas, por su puesto, la capa de Servicio esta excluida como alternativa.

Quedo atento.

Muchas gracias por tu aportes.

    public IEnumerable<Book> TresPrimeroLibrosDeLaColeccion()
    {
        return booksCollection.Take(3)
        .Select(p => new Item(p.Title, p.PageCount) { Title = p.Title, PageCount = p.PageCount});
    }
```    public IEnumerable\<Book> TresPrimeroLibrosDeLaColeccion()    {        return booksCollection.Take(3)        .Select(p => new Item(p.Title, p.PageCount) { Title = p.Title, PageCount = p.PageCount});    }

public IEnumerable<object> TituloNumeroPagdeTresPrimerosLibros()
    {
        var libros = librosCollection
            .OrderByDescending(p => p.PageCount)
            .Take(3)
            .Select(p => new { Title = p.Title, Paginas= p.PageCount });

        foreach (var libro in libros)
        {
            Console.WriteLine($"Título: {libro.Title}, Fecha de Publicación: {libro.Paginas}");
        }

        return libros ;
    }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Curso_Linq
{
    internal class Item
    {
        public string? Title { get; set; }
        public int PageCount { get; set; }
    }
}

internal class LinqQueriesItems
    {

        private List<Item> items = new List<Item>();
        public LinqQueriesItems()
        {
            using (StreamReader reader = new StreamReader("books.json"))
            {
                string json = reader.ReadToEnd();
                this.items = System.Text.Json.JsonSerializer.Deserialize<List<Item>>(json, new System.Text.Json.JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
            }
        }

        public IEnumerable<Item> PrimerosXLibros(int quantity)
        {
            return items.Take(quantity)
                .Select(book => new Item()
                {
                    Title = book.Title,
                    PageCount = book.PageCount
                });
        }
    }

LinqQueriesItems items = new();

string formatoTextoItem = "{0, -60} {1, 15}";

        void ImprimirItems(IEnumerable<Item> listaDeItems)
        {
            Console.WriteLine($"{formatoTextoItem}\n", "Titulo", "N. Paginas");
            foreach (var book in listaDeItems)
            {
                Console.WriteLine($"{formatoTextoItem}", book.Title, book.PageCount);
            }
        }

//* Primeros X libros filtadros con Select
        ImprimirItems(items.PrimerosXLibros(3));

Selección dinámica de datos

Introducción

Bienvenida al curso

Prerrequisitos

¿Qué es LINQ?

Programación declarativa vs. imperativa

Utilizando LINQ por primera vez

Configuración de proyecto

Creando el proyecto base

Configurando clases

Importando datos

Operadores básicos

Usando el operador Where

Ejercicio para aplicar el operador Where

Operadores All y Any

Operador Contains

Operadores OrderBy y OrderByDescending

Ejercicio operador OrderBy

Operadores Take y Skip

Selección dinámica de datos

Operadores de agregación

Operadores LongCount y Count

Operadores Min y Max

Operadores MinBy y MaxBy

Operadores Sum y Aggregate

Operador Average

Agrupamiento de datos

Cláusula GroupBy

Ejercicio cláusula GroupBy

Cláusula Lookup

Cláusula Join

Cierre de curso

Recapitulación sobre LINQ