Operador Contains

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

Cristian Pisco Intriago

student•

Utilizando Query Expression

// retornar los elementos que pertenezcan a la categoria de Python
void Challenge_5(IEnumerable<Book> books)
{
    // extension method
    //var result = books.Where(b => b.Categories.Contains("Python"));

    // query expression
    var result = from b in books where b.Categories.Contains("Python") select b;

    PrintValues(result);
}

Jimmy Buriticá Londoño

student•

Operador Contains

Se usa para encontrar los registros que contienen un determinado string.

Alejandro Betancur

student•

//Query expression (experiment)
        return from book in booksCollection where book.Categories.Contains("Python") select book;

Betzabhe Elizabeth Vega Aliaga

student•

 public IEnumerable<Book> containsPython()
    {
        return from p in librosCollection where p.Categories.Contains("Python") select p;
    }
``` public *IEnumerable*\<Book> containsPython()    {        return from p in librosCollection where p.Categories.Contains("Python") select p;    }

Dario Mendoza

student•

nice

Julián Restrepo Baron

student•

El código que propone el profe es KeySensitive por lo cual no encontraría libros para "python".

Para evitar la detección de mayúsculas y minúsculas se puede añadir un argumento al llamar el método Contains(), así:

Contains(keyword, StringComparer.CurrentCultureIgnoreCase))
```Contains(keyword, StringComparer.CurrentCultureIgnoreCase))

Cristancho Arbld

student•

 public IEnumerable<Book> LibrosPorCategoria(string method, string categoria)
    {
        if (method is "method")
        {
            return _booksCollection.Where(x => x.Categories.Contains(categoria, StringComparer.CurrentCultureIgnoreCase));
        }
        else if (method is "query")
        {
            return from b in _booksCollection
                   where b.Categories.Contains(categoria, StringComparer.CurrentCultureIgnoreCase)
                   select b;
        }
        else
        {
            return Enumerable.Empty<Book>();
        }
    }

Daniel Alberto Vega Bejarano

student•

Porque en los arrays el termino tiene que ser exacto y en las variables no?

Por ejemplo, al intentar buscar con Contains("Pyt") en el titulo me retorna la lista, pero al intentarlo con el array, es decir la subcategoria con una lista, no me retorna nada.

David Jafet Espejel Vázquez

student••

Porque en los arrays busca el valor que es igual a "Pyt". Mientras que en el título busca la subcadena "Pyt". El título es de tipo string y categories un arreglo de strings.

Edinson Arteaga

student•

Un saludo a todos,

¿Cómo sería una consulta donde no sabemos si la palabra que está buscando dentro del arreglo se encuentra en mayúsculas o minúsculas?

Miguel Teheran

teacher•

Puedes utilizar los operadores de ToLower o ToUpper para transformar todo en mayusculas o minusculas y poder comprar los textos

kolab Linkear

student•

Utilizando Method Expresion:

Joan Alexander Valerio Rodríguez

student•

public IEnumerable<Book> CategoriesContainBook()
    {
        //Extension method
        return BooksCollections.Where(p => p.Categories.Contains("Python"));
        
        //Query Expression
        var query = from p in BooksCollections
                    where(p.Categories.Contains("Python"))
                    select p;
        return query;
    }

Wilson Bienvenido Otaño Mateo

student•

Si quieren poder imprimir las categorías pueden usar esta forma, les imprimira los valores del array de categorias.

ImprimirValores(queries.CategoriaPython());

        void ImprimirValores(IEnumerable<Book> listdelibros){
            System.Console.WriteLine("{0, -60} {1, 15} {2, 11} {3, 17}\n", "Titulo", "N. Paginas", "Fecha publicacion", "Categoria"); //los valores de entre {} nos permiten decir le al sistema que queremos que se impriman de una parte hasta otra
            System.Console.WriteLine(new string('-', 90));
            foreach (var item in listdelibros)
            {   
                string categoria = string.Join(", ", item.Categories);
                System.Console.WriteLine("{0, -60} {1, 15} {2, 11} {3, 24} ", item.Title, item.PageCount, item.PublishedDate.ToShortDateString(), categoria);
                
            }
        }
```ImprimirValores(queries.CategoriaPython());
        void ImprimirValores(IEnumerable\<Book> listdelibros){            System.Console.WriteLine("{0, -60} {1, 15} {2, 11} {3, 17}\n", "Titulo", "N. Paginas", "Fecha publicacion", "Categoria"); //los valores de entre {} nos permiten decir le al sistema que queremos que se impriman de una parte hasta otra            System.Console.WriteLine(new string('-', 90));            foreach (var item in listdelibros)            {                   string categoria = string.Join(", ", item.Categories);                System.Console.WriteLine("{0, -60} {1, 15} {2, 11} {3, 24} ", item.Title, item.PageCount, item.PublishedDate.ToShortDateString(), categoria);                            }        }

Wilson Bienvenido Otaño Mateo

student•

Wilson Bienvenido Otaño Mateo

student•

Si quieren poder imprimir las categorías pueden usar esta forma, les imprimira los valores del array de categorias

ImprimirValores(queries.CategoriaPython()); void ImprimirValores(IEnumerable<Book> listdelibros){ System.Console.WriteLine("{0, -60} {1, 15} {2, 11} {3, 17}\n", "Titulo", "N. Paginas", "Fecha publicacion", "Categoria"); //los valores de entre {} nos permiten decir le al sistema que queremos que se impriman de una parte hasta otra System.Console.WriteLine(new string('-', 90)); foreach (var item in listdelibros) { string categoria = string.Join(", ", item.Categories); System.Console.WriteLine("{0, -60} {1, 15} {2, 11} {3, 24} ", item.Title, item.PageCount, item.PublishedDate.ToShortDateString(), categoria); } }

Alejandro Franco López

student•

Mi solucion para poder buscar en mayusculas y minusculas

return _librosCollection.Where(``libro``=>``libro``.Categories.Any(``c``=>``c``.ToUpper().Contains(``cat``.ToUpper())));

Wilson Bienvenido Otaño Mateo

student•

No entendí que fue lo que hiciste ahi hermano

Emiliano Perez

student•

Mi solución del desafio:

  public IEnumerable<Book> GetBooksByCategory(string category)
  {
    // Extension method
    return librosCollection?.Where(book => book.Categories.Contains(category)) ?? [];
  }
```  public IEnumerable\<Book> GetBooksByCategory(string category)

&#x20; {

&#x20;   // Extension method

&#x20;   return librosCollection?.Where(book => book.Categories.Contains(category)) ?? \[];

&#x20; }

Alvaro Augusto Perea Ospina

student•

//Primer desafio con metodo Contains:
public IEnumerable<Book> BooksWithCategoryPython() {
  return CollectionBooks.Where(p => p.Categories.Contains("Python"));
}

Angel Qui

student•

public IEnumerable<Book> LibrosQueContienenXPalabraCategoria(string palabra)
{
    return librosCollection.FindAll(p => p.Categories.Contains(palabra));
}
```public IEnumerable\<Book> LibrosQueContienenXPalabraCategoria(string palabra)

{

&#x20;   return librosCollection.Where(p => p.Categories.Contains(palabra));

}

Joel Angel David Barrantes Palacios

student•

Buscando en internet y con el linter de c# me dice que debo usar otros metodos en vez de All y any, estos son los que me recomendaba en .net 7:

public bool AllBooksHasStatus()
    {
        //extension method
        return CollectionBook.TrueForAll(book => book.Status != null);

        //linq query
        // return (from book in CollectionBook where book.Status != null select book).Count() == CollectionBook.Count;
    }

    public bool AnyBookHasBeenPublishByYear(int year)
    {
        //extension method
        return CollectionBook.Exists(book => book.PublishedDate.Year == year);

        //linq query
        // return (from book in CollectionBook where book.PublishedDate.Year == year select book).Any();
    }

Miguel Angel Reyes Moreno

student•

No quememos el valor, hagamos que sea escalable nuestra función:

public IEnumerable<Book> LibrosDeCategoria(string text)
        {
            return librosCollection.Where(book => book.Categories.Contains(text));
        }

//* Libros de Python
        ImprimirValores(queries.LibrosDeCategoria("Python"));

// retornar los elementos que pertenezcan a la categoria de Python
void Challenge_5(IEnumerable<Book> books)
{
    // extension method
    //var result = books.Where(b => b.Categories.Contains("Python"));

    // query expression
    var result = from b in books where b.Categories.Contains("Python") select b;

    PrintValues(result);
}

 public IEnumerable<Book> containsPython()
    {
        return from p in librosCollection where p.Categories.Contains("Python") select p;
    }
``` public *IEnumerable*\<Book> containsPython()    {        return from p in librosCollection where p.Categories.Contains("Python") select p;    }

 public IEnumerable<Book> LibrosPorCategoria(string method, string categoria)
    {
        if (method is "method")
        {
            return _booksCollection.Where(x => x.Categories.Contains(categoria, StringComparer.CurrentCultureIgnoreCase));
        }
        else if (method is "query")
        {
            return from b in _booksCollection
                   where b.Categories.Contains(categoria, StringComparer.CurrentCultureIgnoreCase)
                   select b;
        }
        else
        {
            return Enumerable.Empty<Book>();
        }
    }

public IEnumerable<Book> CategoriesContainBook()
    {
        //Extension method
        return BooksCollections.Where(p => p.Categories.Contains("Python"));
        
        //Query Expression
        var query = from p in BooksCollections
                    where(p.Categories.Contains("Python"))
                    select p;
        return query;
    }

ImprimirValores(queries.CategoriaPython());

        void ImprimirValores(IEnumerable<Book> listdelibros){
            System.Console.WriteLine("{0, -60} {1, 15} {2, 11} {3, 17}\n", "Titulo", "N. Paginas", "Fecha publicacion", "Categoria"); //los valores de entre {} nos permiten decir le al sistema que queremos que se impriman de una parte hasta otra
            System.Console.WriteLine(new string('-', 90));
            foreach (var item in listdelibros)
            {   
                string categoria = string.Join(", ", item.Categories);
                System.Console.WriteLine("{0, -60} {1, 15} {2, 11} {3, 24} ", item.Title, item.PageCount, item.PublishedDate.ToShortDateString(), categoria);
                
            }
        }
```ImprimirValores(queries.CategoriaPython());
        void ImprimirValores(IEnumerable\<Book> listdelibros){            System.Console.WriteLine("{0, -60} {1, 15} {2, 11} {3, 17}\n", "Titulo", "N. Paginas", "Fecha publicacion", "Categoria"); //los valores de entre {} nos permiten decir le al sistema que queremos que se impriman de una parte hasta otra            System.Console.WriteLine(new string('-', 90));            foreach (var item in listdelibros)            {                   string categoria = string.Join(", ", item.Categories);                System.Console.WriteLine("{0, -60} {1, 15} {2, 11} {3, 24} ", item.Title, item.PageCount, item.PublishedDate.ToShortDateString(), categoria);                            }        }

  public IEnumerable<Book> GetBooksByCategory(string category)
  {
    // Extension method
    return librosCollection?.Where(book => book.Categories.Contains(category)) ?? [];
  }
```  public IEnumerable\<Book> GetBooksByCategory(string category)

&#x20; {

&#x20;   // Extension method

&#x20;   return librosCollection?.Where(book => book.Categories.Contains(category)) ?? \[];

&#x20; }

public IEnumerable<Book> LibrosQueContienenXPalabraCategoria(string palabra)
{
    return librosCollection.FindAll(p => p.Categories.Contains(palabra));
}
```public IEnumerable\<Book> LibrosQueContienenXPalabraCategoria(string palabra)

{

&#x20;   return librosCollection.Where(p => p.Categories.Contains(palabra));

}

public bool AllBooksHasStatus()
    {
        //extension method
        return CollectionBook.TrueForAll(book => book.Status != null);

        //linq query
        // return (from book in CollectionBook where book.Status != null select book).Count() == CollectionBook.Count;
    }

    public bool AnyBookHasBeenPublishByYear(int year)
    {
        //extension method
        return CollectionBook.Exists(book => book.PublishedDate.Year == year);

        //linq query
        // return (from book in CollectionBook where book.PublishedDate.Year == year select book).Any();
    }

Operador Contains

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