Strategy Pattern e Princípios SOLID em Dart

O Strategy Pattern é um padrão de projeto comportamental que permite que um algoritmo ou comportamento seja selecionado em tempo de execução. Isso é útil quando há vários algoritmos relacionados, mas o algoritmo específico a ser usado não é conhecido até o tempo de execução.

Implementação do Strategy Pattern

Em Dart, o Strategy Pattern pode ser implementado usando interfaces e classes abstratas. A interface define o método que todos os algoritmos devem implementar, enquanto as classes abstratas fornecem implementações específicas desses métodos.

Por exemplo, considere a seguinte interface para o algoritmo de filtragem de produtos:

abstract class ProductFilterStrategy {
List<Product> filter(List<Product> products);
}

Essa interface define um método filter() que recebe uma lista de produtos e retorna uma lista filtrada.

Agora, podemos criar classes que fornecem implementações específicas do método filter():

class FilterByPriceStrategy implements ProductFilterStrategy {
final double price;

FilterByPriceStrategy(this.price);

@override
List<Product> filter(List<Product> products) {
  return products.where((product) => product.price <= price).toList();
}
}
class FilterByCategoryStrategy implements ProductFilterStrategy {
final int category;

FilterByCategoryStrategy(this.category);

@override
List<Product> filter(List<Product> products) {
  return products.where((product) => product.category == category).toList();
}
}
class FilterByAvailabilityStrategy implements ProductFilterStrategy {
@override
List<Product> filter(List<Product> products) {
  return products.where((product) => product.isAvailable).toList();
}
}

Essas classes definem os algoritmos específicos de filtragem por preço, categoria e disponibilidade, respectivamente.

Utilização do Strategy Pattern

O aplicativo pode então usar essas estratégias para filtrar a lista de produtos:

// Cria uma lista de produtos
List<Product> products = [...];

// Cria uma instância da estratégia de filtragem por preço
ProductFilterStrategy filterByPriceStrategy = FilterByPriceStrategy(2000);

// Filtra a lista de produtos usando a estratégia de filtragem por preço
List<Product> filteredProducts = filterByPriceStrategy.filter(products);

Princípios SOLID

O Strategy Pattern pode ser usado para implementar os seguintes princípios SOLID:

• Princípio da Responsabilidade Única (SRP): Cada classe deve ter uma única responsabilidade. No exemplo acima, a interface ProductFilterStrategy define a responsabilidade de filtrar uma lista de produtos, enquanto as classes FilterByPriceStrategy, FilterByCategoryStrategy e FilterByAvailabilityStrategy fornecem implementações específicas dessa responsabilidade.
• Princípio da Abertura/Fechamento (OCP): As classes devem ser abertas para extensão, mas fechadas para modificação. Isso significa que novas funcionalidades podem ser adicionadas ao sistema sem modificar as classes existentes. No exemplo acima, a interface ProductFilterStrategy está aberta para extensão, pois permite que novas estratégias de filtragem sejam adicionadas sem modificar a interface.
• Princípio da Substituição de Liskov (LSP): As subclasses devem ser substituíveis por suas superclasses. Isso significa que qualquer lugar onde uma superclasse é esperada, uma subclasse pode ser usada sem causar problemas. No exemplo acima, as classes FilterByPriceStrategy, FilterByCategoryStrategy e FilterByAvailabilityStrategy são subclasses da interface ProductFilterStrategy, e podem ser usadas em qualquer lugar onde uma instância de ProductFilterStrategy é esperada.
• Princípio da Inversão de Dependência (DIP): As classes devem depender de abstrações, e não de implementações concretas. No exemplo acima, a classe GetProductsUseCase depende da interface ProductFilterStrategy, e não de uma implementação específica como FilterByPriceStrategy.

Conclusão

O Strategy Pattern é um padrão de projeto poderoso que pode ser usado para melhorar a flexibilidade e a extensibilidade do código. Ao usar o Strategy Pattern, os algoritmos podem ser facilmente alterados e personalizados sem afetar o restante do código.

Além disso, o Strategy Pattern pode ajudar a implementar os princípios SOLID, o que pode tornar o código mais fácil de manter e testar.