The Repository Pattern is a pattern that defines how to access data in a reusable, isolated fashion. The core concept is to isolate the logic required to call a database, file, or other data source. It can be reused without other layers of the software needing to know the details of how to get that data. An example would be the connection string for a database should be used in 1 location, within a repository, rather than every class that needed data needing a connection string.
The repository is used by calling classes like a collection of data. If I have an employee repository, classes that need an employee can query the employee repository as if all employees were already in an in-memory collection.
I view the repository as the bottom layer of code.
Isolating data access from the rest of your code has multiple benefits. You can easily write tests by faking or mocking your repository. You do not actually connect to your data source in your tests, instead your repository actually becomes an in-memory collection. It also means that you can setup your data specific for each test and know that it will be in a known good state.
You could also setup caching within your repository which would isolate that logic away from other parts of your system. It also makes it much easier to change how or where your data is stored if you have the need.
A couple of potential drawbacks come to mind with this pattern. First this could create more classes and files within your project. Some would view this as adding complexity, but I feel the benefits would be well worth it. Another possible drawback could be in optimizing your data access. The defaults for your repository might not be the most performant way to query your data. This is likely not going to be a huge issue unless you are working on something that you need to squeeze out every efficiency to make your project successful. In those cases, you could still utilize the repository pattern, but you would need to do extra work to improve performance where needed.
This interface will likely cover the majority of your needed, but there is always the ability to expand on it when you have more specific queries that you want to reuse.
With this IEmployeeRepository we get all of the methods from IRepository through inheritance and add onto those the methods that most make sense for employees.
One thing I came across while researching the repository pattern was that the repository might not need to have a Save function if you use the Unit of Work Pattern. To better understand why that would be the case, I plan to research the Unit of Work Pattern next.
The repository is used by calling classes like a collection of data. If I have an employee repository, classes that need an employee can query the employee repository as if all employees were already in an in-memory collection.
var employee = _employeeRepository.FindById(1);
I view the repository as the bottom layer of code.
Isolating data access from the rest of your code has multiple benefits. You can easily write tests by faking or mocking your repository. You do not actually connect to your data source in your tests, instead your repository actually becomes an in-memory collection. It also means that you can setup your data specific for each test and know that it will be in a known good state.
You could also setup caching within your repository which would isolate that logic away from other parts of your system. It also makes it much easier to change how or where your data is stored if you have the need.
A couple of potential drawbacks come to mind with this pattern. First this could create more classes and files within your project. Some would view this as adding complexity, but I feel the benefits would be well worth it. Another possible drawback could be in optimizing your data access. The defaults for your repository might not be the most performant way to query your data. This is likely not going to be a huge issue unless you are working on something that you need to squeeze out every efficiency to make your project successful. In those cases, you could still utilize the repository pattern, but you would need to do extra work to improve performance where needed.
How I would setup a repository in my code
You could create a repository for each and every different data object that you needed, but I have found that most repositories tend to share enough common methods that you can start with a generic repository and build more specific ones as needed.public interface IRepository<T> where T : IEntity { T GetById(int id); List<T> GetAll(Expression<Func<T, bool>> where); void Delete(T entity); void Add(T entity); T Save(T entity); }
This interface will likely cover the majority of your needed, but there is always the ability to expand on it when you have more specific queries that you want to reuse.
public interface IEmployeeRepository: IRepository<Employee> { List<Employee> GetManagers(); List<Employee> GetNew(); List<Employee> GetAllByRole(RoleEnum role); }
With this IEmployeeRepository we get all of the methods from IRepository through inheritance and add onto those the methods that most make sense for employees.
One thing I came across while researching the repository pattern was that the repository might not need to have a Save function if you use the Unit of Work Pattern. To better understand why that would be the case, I plan to research the Unit of Work Pattern next.
Comments
Post a Comment