Il modello di strategia non è sufficiente per il mio problema?

Lasciatemi abbozzare la situazione:

• Ho più utenti, con determinate proprietà (2 enumerazioni)
• Per ogni utente ho bisogno di recuperare i dati, per alcuni con alcuni filtri di base, per alcuni filtri estesi (= filtro di base + filtro aggiuntivo). Mi piacerebbe farlo non separato per ogni utente, ma preferirei raggruppare gli utenti e farlo in due query.
• Per ogni utente, ho bisogno di filtrare i dati in base ai valori dell'enumerazione. sempre devo fare GetFirstData() (metodo che dipende dal primo enum), GetLastData() (metodo che dipende dal secondo enum), CheckData() (dipende da entrambe le enumerazioni).

Ho esaminato il Pattern di strategia , ma sembra che sia più progettato per implementare un comportamento. Voglio combinare i miei comportamenti per evitare di creare le combinazioni tra tutti GetFirstData e GetLastData , c'è qualche schema per farlo meglio? Ho pensato solo a usare 2 delegati e assegnare i metodi corrispondenti in base ai valori delle enumerazioni . Questo sarebbe il modo più pulito?

Piccolo esempio di cosa intendo:

public class User
{
   public Enum1 FirstEnum {get; set;}
   public Enum2 SecondEnum {get; set;}
   ...
}
public IEnumerable<Data> Filter(int userId, Expression extraFilter)
{
    var data = GetData(userId);
    if(extraFilter != null)
      data = data.Where(extraFilter);
    return data;
}
public Data GetFirstData(IEnumerable<Data> data);
public Data GetLastData(IEnumerable<Data> data);
public bool CheckData(IEnumerable<Data> data);

Il mio endresult potrebbe fare qualcosa del genere:

public class EndResult
{
    public Data FirstResult {get; set;}
    public Data SecondResult {get; set;}
    public Func<IEnumerable<Data>,Data> GetFirstData {get; set;}
    public Func<IEnumerable<Data>,Data> GetLastData {get; set;}
    public bool ExtendeFiltering {get; set;}

    public EndResult(User user)
    {
        switch(user.enum1)
        {
            case: GetFirstData = specificFunction;
                  ExtendedFiltering = true;
            ...
        }
        //Second for GetLastData;
    }

    public void Execute()
    {
        GetData();
        CheckData();
        GetFirstData();
        GetLastData();
    }
}

Modifica: per i futuri lettori che sono curiosi, non ho usato i delegati (almeno non direttamente). Ho creato 2 interfacce IFirst e ILast con un metodo corrispondente. Nel mio metodo di creazione statico definito sulla mia classe di processore, eseguo la logica per creare un'istanza di tali interfacce in base a determinate condizioni. Il motivo per cui ho lasciato il percorso usando direttamente i delegati è perché ho scoperto che avevo bisogno di più parametri rispetto a User per alcuni di essi. Così ho fatto ricorso a diverse implementazioni basate sui parametri che ho bisogno nel costruttore di quelle classi.