Domanda di architettura

Sto scrivendo un regolamento / modulo di ammissibilità. Ho 2 set di dati, uno è i dati del cliente e l'altro è i dati dei prodotti del cliente. I dati dei clienti per i dati dei prodotti dei clienti sono uno a molti.

Ora devo passare attraverso una serie di regole di idoneità per ciascuno di questi dati di prodotto del cliente. Per ogni dato sui prodotti dei clienti, posso dire che il cliente è idoneo per quel prodotto o rifiuta l'idoneità e dovrebbe passare al record del prodotto successivo.

Quindi, in tutte le regole, ho bisogno di avere accesso ai dati sui prodotti dei clienti e dei clienti (il record particolare in cui le regole vengono eseguite contro). Poiché tutte le regole possono approvare un prodotto o rifiutare un prodotto, ho creato un'interfaccia con questi 2 metodi e sto implementando questa interfaccia per tutte le regole. Sto passando i dati del cliente e i dati di un prodotto per tutte le regole (perché le regole dovrebbero essere eseguite su ogni riga di dati del prodotto del cliente). Una situazione ideale sarebbe avere i dati sui prodotti cliente e cliente disponibili per la regola invece di passarli a ciascuna regola.

Qual è il modo migliore di fare questo in termini di architettura?

Modifica: ecco cosa sto facendo

public class CustomerContract
{
    public DateTime StartDate { get; set; }
    public DateTime endDate { get; set; }
    //Other Contract related details

}
public class Customer
{
    public int ID { get; set; }
    public string Name { get; set; }
    public string state { get; set; }
}

public class CustomerInfo
{
    public CustomerInfo(int CustomerID)
    {
        Customer = new Customer();// Get Customer from DB
        AppliedProducts = new List<CustomerProduct>();// Get the customer products by customerID
        CurrentContract = new CustomerContract();//Get the contract by CustomerID, State
        declineReasons = new List<int>();// just intailizing. the decline codes are added by rules.
    }

    public CustomerContract CurrentContract { get; set; }
    public IList<CustomerProduct> AppliedProducts { get; set; }
    public IList<int> declineReasons { get; set; }
    public Customer Customer { get; set; }
}

public class CustomerProduct
{
    public decimal AmountCharged { get; set; }
    public int DeclineReasonID { get; set; }
    public int Product { get; set; }
    public decimal DiscountApplicable { get; set; }
    public decimal AmountQuoted { get; set; }
    public decimal Tax { get; set; }
}

public interface IRule
{
    // Since we need to have access to contracts when deciding the eligibility
    CustomerProduct ExecuteRule(CustomerProduct currentproduct, CustomerInfo customerInfo);

    //when denied, 
    CustomerProduct DenyProduct(CustomerProduct currentProduct);
}

public class EligibityEngine
{
    List<IRule>  rules = new List<IRule>();
    private CustomerInfo c;

    public EligibityEngine(int CustomerID)
    {
        c = new CustomerInfo(CustomerID);
        LoadRules();
        foreach (var customerProduct in c.AppliedProducts)
        {
            ExecuteRules(customerProduct);
        }
    }

    private void ExecuteRules(CustomerProduct currentProductItem)
    {
        foreach (var rule in rules)
        {
            currentProductItem = rule.ExecuteRule(currentProductItem, c);
        }
    }

    private void LoadRules()
    {
        // add all the IRule types here
        //rules.Add();
    }
}

Quando eseguo la regola, ho passato i dati del prodotto del cliente e i dati del cliente. Devo passare il risultato di un'esecuzione di una regola all'altra. Nel modello precedente, se la regola modifica i dati nella classe customerInfo, non viene salvata a meno che non passi come riferimento.

La mia domanda è che voglio che tutte le regole abbiano accesso a questi dati senza passarli. Quindi non mi devo preoccupare di catturare la regola.

Voglio il metodo executeRule per annullare.