Qual è il modo migliore per ottenere dati dal database per i dati che vengono utilizzati di frequente?

Per renderlo davvero flessibile e trasparente, hai bisogno di un'interfaccia e di un paio di classi concrete che implementano l'interfaccia, e di evitare classi e metodi statici per una vera programmazione orientata agli oggetti:

public interface IEmployeeRepository
{
    IEnumerable<Employee> FindByUnit(int unitId);
    Employee Find(int id);
}

Sto aggiungendo un metodo Find all'interfaccia per illustrare in seguito la difficoltà di memorizzare nella cache questi oggetti.

Ora, la classe EmployeeRepository implementa l'interfaccia IEmployeeRepository , che interroga il database ogni volta:

public class EmployeeRepository : IEmployeeRepository
{
    public EmployeeRepository(string connectionString)
    {
        if (string.IsNullOrEmpty(connectionString))
            throw new ArgumentNullException("connectionString");

        this.connectionString = connectionString;
    }

    private string connectionString;

    public Employee Find(int id)
    {
        // Query by Id and return a single Employee
    }

    public IEnumerable<Employee> FindByUnit(int unitId)
    {
        // Query the database and return the list of employees
    }
}

Ora un codice che utilizza la classe e l'interfaccia concrete:

IEmployeeRepository repository = new EmployeeRepository("...");

IEnumerable<Employee> employees = repository.FindByUnit("3");

Questo ti porta dove sei attualmente. Il database viene interrogato ogni volta. Ora possiamo introdurre alcuni caching:

public class CachedEmployeeRepository : IEmployeeRepository
{
    public CachedEmployeeRepository(IEmployeeRepository employees)
    {
        if (employees == null)
            throw new ArgumentNullException("employees");

        this.employees = employees;
        this.cacheById = new Dictionary<int, Employee>();
        this.cacheByUnitId = new Dictionary<int, Employee>();
    }

    private Dictionary<int, Employee> cacheById;

    private Dictionary<int, IEnumerable<Employee>> cacheByUnitId;

    public Employee Find(int id)
    {
        Employee employee = null;

        if (cacheById.ContainsKey(id))
        {
            employee = employees.Find(id);

            if (employee != null)
            {
                cacheById[id] = employee;
            }
        }
        else
        {
            employee = cacheById[id];
        }

        return employee;
    }

    public IEnumerable<Employee> FindByUnit(int unitId)
    {
        if (cacheByUnitId.ContainsKey(unitId))
        {
            return cacheByUnitId[unitId];
        }

        IEnumerable<Employee> results = employees.FindByUnit(unitId);

        if (results.Any())
        {
            cacheByUnitId[unitId] = results;
        }

        return results;
    }
}

Il CachedEmployeeRepository prende un EmployeeRepository nel suo costruttore e implementa l'interfaccia IEmployeeRepository . Ora puoi introdurre la cache senza problemi nella tua applicazione:

IEmployeeRepository repository = new CachedEmployeeRepository(
    new EmployeeRepository("..."));

IEnumerable<Employee> employees = repository.FindByUnit("3");

Il resto del codice non sa nemmeno, o ha bisogno di sapere, che il caching sta accadendo.

Ma attenzione con il caching. Osserva la ricerca di un dipendente da parte di Id e un elenco di essi per ID unità ha cache diverse e quindi diverse istanze della classe Employee .

There are two hard things in computer science: cache invalidation, naming things, and off-by-one errors. - Martin Fowler

È possibile implementare una cache semplice come questa:

public class DatabaseHelper
{
    static private Dictionary<string,List<Employee>> _lookup = new Dictionary<string, List<Employee>>();

    static public List<Employee> GetEmployees(string unitID, bool refresh)
    {
        List<Employee> list;

        if (!refresh)
        {            
            bool exists = _lookup.TryGetValue(unitID, out list);
            if (exists) return list;
        }

        list = GetEmployees(unitID);
        _lookup[unitID] = list;
        return list;
    }

   static private List<Employee> GetEmployees(string unitID)
   {
       //You already wrote this part
   }
}