No tienes acceso a esta clase

¬°Contin√ļa aprendiendo! √önete y comienza a potenciar tu carrera

Aprende Inglés, Programación, AI, Ciberseguridad y mucho más.

Antes: $249

Currency
$209
Suscríbete

Termina en:

2 Días
22 Hrs
33 Min
27 Seg

Operador Contains

12/26
Recursos

Aportes 12

Preguntas 1

Ordenar por:

¬ŅQuieres ver m√°s aportes, preguntas y respuestas de la comunidad?

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

Operador Contains

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

//Query expression (experiment)
        return from book in booksCollection where book.Categories.Contains("Python") select book; 
 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>();
        }
    }
Mi solucion para poder buscar en mayusculas y minusculas `return _librosCollection.Where(``libro``=>``libro``.Categories.Any(``c``=>``c``.ToUpper().Contains(``cat``.ToUpper())));`
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√≠: ```js Contains(keyword, StringComparer.CurrentCultureIgnoreCase)) ```Contains(keyword, StringComparer.CurrentCultureIgnoreCase))
```js 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;    }
Mi solución del desafio: ```js public IEnumerable<Book> GetBooksByCategory(string category) { // Extension method return librosCollection?.Where(book => book.Categories.Contains(category)) ?? []; } ``` public IEnumerable\<Book> GetBooksByCategory(string category) { // Extension method return librosCollection?.Where(book => book.Categories.Contains(category)) ?? \[]; }
```c# //Primer desafio con metodo Contains: public IEnumerable<Book> BooksWithCategoryPython() { return CollectionBooks.Where(p => p.Categories.Contains("Python")); } ``` ```c# ``` ```js ```
```js public IEnumerable<Book> LibrosQueContienenXPalabraCategoria(string palabra) { return librosCollection.FindAll(p => p.Categories.Contains(palabra)); } ```public IEnumerable\<Book> LibrosQueContienenXPalabraCategoria(string palabra) { return librosCollection.Where(p => p.Categories.Contains(palabra)); }

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

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