using System;

using System.Collections.Generic;

using System.Linq;

using System.Linq.Expressions;

​

public class Program

{

    //Questa interfaccia la metti nel model

    public interface IFilter<T>{

        Expression<Func<T, bool>> Espressione { get; }

    }

    //Questa è una classe di entità, anche lei nel model

    public class Cliente{

        public int IdCliente {get;set;}

        public string Nome {get;set;}

        public bool ClienteVip {get;set;}

    }

    //Questo è un metodo del business layer

    public static IEnumerable<Cliente> RicercaClienti(IFilter<Cliente> filtro){

        //Ai fini della demo creo un'istanza del repository

        //ma tu avrai a che fare con IRepository<T>

        var repo = new RepositoryClienti();

        //Qui uso il filtro che mi è stato passato

        return repo.GetMany(filtro.Espressione);

    }

    //Questa è un'implementazione dimostrativa del repository che ha il metodo GetMany

    //La tua ovviamente implementerà IRepository<T>

    public class RepositoryClienti {

        public IEnumerable<Cliente> GetMany(Expression<Func<Cliente, bool>> where){

          //Dati fittizi che tu invece ottieni dal db

          var clienti = (new [] {

                new Cliente { IdCliente = 1, Nome = "Mario Rossi", ClienteVip = false },

                new Cliente { IdCliente = 2, Nome = "Luigi Verdi", ClienteVip = true },

                new Cliente { IdCliente = 3, Nome = "Enzo Neri", ClienteVip = false },

          }).AsQueryable();

          return clienti.Where(where);

        }

    }

    //Questa implementazione di IFilter può essere dove vuoi, anche nella UI

    //Permetto all'utente di questa classe di passare il suo criterio di filtraggio

    //come Func<Cliente, bool>, ma avrei potuto usare anche altri sistemi. Stringhe? Sì, ma meglio di no.

    public class FiltroClienti : IFilter<Cliente> {

        private readonly Expression<Func<Cliente, bool>> espressioneFiltro;

        public FiltroClienti(Expression<Func<Cliente, bool>> espressioneFiltro){

            this.espressioneFiltro = espressioneFiltro;

        }

        public Expression<Func<Cliente, bool>> Espressione { get { return espressioneFiltro; } }

    }

    public static void Main()

    {

        //Qui siamo nella UI.

        //Per prima cosa imposto un'espressione (voglio ottenere solo i clienti VIP). La posso costruire in base a ciò che l'utente ha selezionato dal form

        //Qui la imposto staticamente per semplificare.

        Expression<Func<Cliente, bool>> espressioneFiltro = cliente => cliente.ClienteVip == true;

        //Poi creo un'istanza del filtro passandogli l'espressione

        var filtro = new FiltroClienti(espressioneFiltro);

        //Al metodo RicercaClienti non interessa che io stia passando un FiltroClienti (che è implementato a tuo piacimento)

        //L'importante è passare un qualcosa che implementi IFilter<Cliente>

        var clientiFiltrati = RicercaClienti(filtro);

        //Verrà stampato il solo cliente VIP

        foreach (var cliente in clientiFiltrati){

            Console.WriteLine(cliente.Nome);

        }

    }

}