Operadores LongCount y Count

Contenido del curso

Introducción

Configuración de proyecto

Operadores básicos

Operadores de agregación

Agrupamiento de datos

Cierre de curso

26
Recapitulación sobre LINQ
03:20 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0010:02

Operadores LongCount y Count

Curso de Manejo de Datos en C# con LINQ

Clase 17 de 26

Clase 17 / 26

Comentarios (14)14 comentarios

Pedro Marval

Hace 4 años

también se puede hacer la condición dentro del método count, ella recibe como parámetro una expresión predicado

Jose Antonio Diaz Urbano

Hace 4 años

Hasta ahora en todas las clases estoy pausando el video para hacer el reto por mi cuenta y quitando una que no pude hacerlo el resto si lo he podido hacer. Muy recomendable que hagáis lo mismo para asentar las bases

Carlos Andres Bohorquez Duran

Hace 4 años

Estoy haciendo lo mismo

Lissett Paez

Hace 3 años

Hasta el momento no pude resolver uno pero del resto estoy haciendo igual jeje

Katerin Calderón

Hace 3 años

Utilizando una arrow function y con el predicate dentro del Count queda asi:

        public int NumberBooksBetween200And500Pages() =>
            booksCollection
            .Count(book => book.PageCount >= 200 && book.PageCount <= 500);

Diego Eduardo Téllez Contreras

Hace 3 años

Es decir, viene siendo similar al .length en JavaScript. Se utiliza para obtener la longitud o cantidad de elementos en una colección.

Gustavo Fernández

Hace 2 años

Si que yes!

Jimmy Buriticá Londoño

Hace 4 años

Operadores LongCount y Count

Ambos operadores regresan la cantidad de registros que cumplen una condición específica.

David Cubides Enciso

Hace 4 años

Utilice el filtro en el Count() y tambien cumple con el objetivo, una linea menos.

return librosCollection.Count(p => p.PageCount > 400 && p.PageCount < 500);

Joan Alexander Valerio Rodríguez

Hace 2 años

Les comparto mis ejercicios utilizando Extension method y Query Expression utilizando ambos operadores: LongCount y Count.

//Count()

//Extension method
return BooksCollections
       .Count(p => p.PageCount >= 200 & p.PageCount <= 500);
        
//Query Expression
var query = (from p in BooksCollections
             where p.PageCount >= 100 & p.PageCount <= 600
             select p)
             .Count();
        
return query;

//LongCount()

//Extension method
return BooksCollections
       .LongCount(p => p.PageCount > 0 & p.PageCount <= 1000);
        
//Query Expression
var query = (from p in BooksCollections
            where p.PageCount > 0 & p.PageCount <= 1000
            select p).LongCount();
        
return query;

Leonardo Valdivieso

Hace 4 años

Pruebo hacerlo con una query expression:

        public long LibrosMas200Menos500paginas()
        {
            return (
                from l in librosCollection 
                where l.PageCount >= 200 && l.PageCount <= 500 
                select l)
                .LongCount();
        }

VICTOR CAUDILLO

Hace 3 años

Fantástica Clase <3

Cristhian Alexis Vera Sandoval

Hace 5 meses

¿Cuándo debo usar LongCount en lugar de Count?

Debes usar LongCount únicamente cuando trabajes con colecciones de datos masivas que superen el límite máximo de un número entero tradicional (int.MaxValue), el cual es aproximadamente 2.14 mil millones de elementos. En la gran mayoría de las aplicaciones cotidianas, Count es más que suficiente y consume menos memoria. Sin embargo, si estás procesando flujos de datos gigantescos, como registros de telemetría a nivel global o análisis de Big Data directamente en memoria, Count lanzará una excepción. Ahí es donde LongCount entra al rescate, devolviendo un tipo long de 64 bits que puede manejar cifras astronómicas sin romper tu aplicación.

Juan Daniel Ramirez Coroy

Hace 2 años

Esta seria la funcion: public int NumberBooksBetween200And500Pages() => booksCollection .Count(book => book.PageCount >= 200 && book.PageCount <= 500);

Angel Qui

Hace 3 años

public int GetCountBetweenPages(int minPages, int maxPages)
{
    return librosCollection
        .Count(b => b.PageCount >= minPages && b.PageCount <= maxPages);
}

Pablo Cesar Lara Londoño

Hace 3 años

Forma de hacerlo sin Where

Miguel Angel Reyes Moreno

Hace 3 años

Antes de ver el vídeo - operador Count:

public int LibrosEntreXYPaginas(int limiteInferior, int limiteSuperior)
        {
            return librosCollection.Count(book => book.PageCount > limiteInferior && book.PageCount < limiteSuperior);
        }

uso:

//* Cantidad de libros entre 200 y 500 páginas
        Console.WriteLine($"Cantidad de libros entre 200 y 500 páginas: {queries.LibrosEntreXYPaginas(200, 500)}");

//Count()

//Extension method
return BooksCollections
       .Count(p => p.PageCount >= 200 & p.PageCount <= 500);
        
//Query Expression
var query = (from p in BooksCollections
             where p.PageCount >= 100 & p.PageCount <= 600
             select p)
             .Count();
        
return query;

//LongCount()

//Extension method
return BooksCollections
       .LongCount(p => p.PageCount > 0 & p.PageCount <= 1000);
        
//Query Expression
var query = (from p in BooksCollections
            where p.PageCount > 0 & p.PageCount <= 1000
            select p).LongCount();
        
return query;

        public long LibrosMas200Menos500paginas()
        {
            return (
                from l in librosCollection 
                where l.PageCount >= 200 && l.PageCount <= 500 
                select l)
                .LongCount();
        }

public int LibrosEntreXYPaginas(int limiteInferior, int limiteSuperior)
        {
            return librosCollection.Count(book => book.PageCount > limiteInferior && book.PageCount < limiteSuperior);
        }

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

CLASE EN ACTUALIZACIÓN (sáltala y avanza a la siguiente)- Ejercicio para aplicar el operador Where

Operadores All y Any

Operador Contains

Operadores OrderBy y OrderByDescending

CLASE EN ACTUALIZACIÓN (sáltala y avanza a la siguiente)- 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

Operadores LongCount y Count

Progreso del curso

Introducción

Configuración de proyecto

Operadores básicos

Operadores de agregación

Agrupamiento de datos

Cierre de curso