public static void FiltrarMusicasPorAno(List<Musica> musicas, string ano)
{
var musicasPorAno = musicas.Where(musica => musica.AnoLancamento!.Contains(ano))
.ToList();
Console.WriteLine($"Exibindo músicas do ano de ({ano})");
foreach (var musica in musicasPorAno)
{
Console.WriteLine(musica.Nome);
}
}
LinqFilter.FiltrarMusicasPorAno(musicas, "2012");
LinqFilter.FiltrarMusicasPorAno(musicas, "2019");
Oi, Paulo! Como vai?
Agradeço por compartilhar.
Gostei da sua implementação, importante notar como você aplicou o Where do LINQ de forma clara para filtrar as músicas pelo ano e organizar bem a exibição no console.
Continue explorando esse tipo de abordagem, isso fortalece bastante sua lógica com LINQ.
Siga praticando variações desse filtro para ganhar ainda mais fluidez.
Conte com o apoio da comunidade Alura na sua jornada. Abraços e bons estudos!
Olá amigo.
Excelente trabalho.
O código está funcional e cumpre o objetivo de filtrar e exibir músicas por ano, porém há alguns pontos que podem ser melhorados em termos de robustez, clareza e boas práticas.
O uso de Contains para comparar o ano pode gerar resultados inesperados caso o campo AnoLancamento contenha valores maiores ou formatos diferentes, como datas completas ou textos, já que uma busca parcial pode retornar músicas de anos não pretendidos.
Se o ano for um valor numérico ou um ano exato, o ideal seria armazená-lo como inteiro e comparar por igualdade, o que torna a intenção do código mais clara e evita ambiguidades.
O uso do operador de supressão de nulo no AnoLancamento indica que a propriedade pode ser nula, mas isso apenas silencia o aviso do compilador e não previne um possível erro em tempo de execução; uma verificação explícita de nulo deixaria o código mais seguro.
Além disso, o método mistura lógica de filtragem com saída no console, o que reduz a reutilização e dificulta testes; uma abordagem mais limpa seria retornar a lista filtrada e deixar a responsabilidade de exibição para quem chama o método.
Por fim, o nome do método está adequado, mas o parâmetro ano como string reforça a fragilidade da comparação, então tipá-lo corretamente ajudaria a tornar o código mais expressivo e menos sujeito a erros.
São apenas sugestões de melhorias que podem ser ou não aplicadas dependendo do contexto.
Segue um exemplo de como ficaria.
Um exemplo aplicando as sugestões seria separar a lógica de filtragem da exibição, usar o ano como inteiro e tratar explicitamente valores nulos. Considerando que a classe Musica tenha a propriedade AnoLancamento como inteiro, o código poderia ficar assim:
public static List<Musica> FiltrarMusicasPorAno(List<Musica> musicas, int ano)
{
if (musicas == null)
{
return new List<Musica>();
}
return musicas
.Where(m => m.AnoLancamento == ano)
.ToList();
}
E a responsabilidade de exibir os dados ficaria fora do método de filtragem:
var musicas2012 = LinqFilter.FiltrarMusicasPorAno(musicas, 2012);
Console.WriteLine("Exibindo músicas do ano de (2012)");
foreach (var musica in musicas2012)
{
Console.WriteLine(musica.Nome);
}
var musicas2019 = LinqFilter.FiltrarMusicasPorAno(musicas, 2019);
Console.WriteLine("Exibindo músicas do ano de (2019)");
foreach (var musica in musicas2019)
{
Console.WriteLine(musica.Nome);
}
Dessa forma o método fica mais seguro, reutilizável e com uma responsabilidade bem definida, além de evitar comparações ambíguas usando string.
Testa ai e avise se isso se aplica ao seu caso.
Em caso de duvidas pode perguntar.
Bons estudos.