Understanding the Repository Pattern in C# .NET Core: Simplifying Data Access

0 0

In modern software development, organizing code in a way that promotes separation of concerns and maintainability is crucial. One common design pattern that helps achieve these goals, especially when dealing with data access, is the Repository Pattern. This pattern abstracts the data access layer and provides a clean and consistent interface to interact with data from various sources, such as databases or web services.

What is the Repository Pattern?

The Repository Pattern is a well-known architectural pattern that acts as a mediator between the business logic layer and the data access layer of an application. It encapsulates the logic required to access data and provides a straightforward API to perform CRUD operations (Create, Read, Update, Delete) on entities.

Why Use the Repository Pattern?

1. Separation of Concerns:

The Repository Pattern separates the business logic from the details of data access implementation. This separation makes the codebase easier to maintain and test.

2. Single Responsibility Principle:

Each repository class has a single responsibility: managing data operations for a specific entity or aggregate root. This promotes cleaner and more maintainable code.

3. Abstraction and Testability:

By defining interfaces for repositories, you can easily switch data access implementations (e.g., from Entity Framework to a mock repository for unit testing) without changing the business logic.

Implementing the Repository Pattern in C# .NET Core

Let’s dive into a practical example of implementing the Repository Pattern using .NET Core, specifically focusing on a blog application scenario with posts and comments.

Step 1: Define Model Classes

public class Post
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public DateTime CreatedAt { get; set; }
    public bool IsPublished { get; set; }
}

public class Comment
{
    public int Id { get; set; }
    public int PostId { get; set; }
    public string Content { get; set; }
    public DateTime CreatedAt { get; set; }
}

Step 2: Create Repository Interfaces

public interface IPostRepository
{
    Task<IEnumerable<Post>> GetAllPostsAsync();
    Task<Post> GetPostByIdAsync(int id);
    Task AddPostAsync(Post post);
    Task UpdatePostAsync(Post post);
    Task DeletePostAsync(int id);
}

public interface ICommentRepository
{
    Task<IEnumerable<Comment>> GetCommentsForPostAsync(int postId);
    Task AddCommentAsync(Comment comment);
    Task DeleteCommentAsync(int id);
}

Step 3: Implement Repository Classes

public class PostRepository : IPostRepository
{
    private readonly BlogDbContext _context;

    public PostRepository(BlogDbContext context)
    {
        _context = context;
    }

    public async Task<IEnumerable<Post>> GetAllPostsAsync()
    {
        return await _context.Posts.ToListAsync();
    }

    public async Task<Post> GetPostByIdAsync(int id)
    {
        return await _context.Posts.FindAsync(id);
    }

    public async Task AddPostAsync(Post post)
    {
        await _context.Posts.AddAsync(post);
        await _context.SaveChangesAsync();
    }

    public async Task UpdatePostAsync(Post post)
    {
        _context.Posts.Update(post);
        await _context.SaveChangesAsync();
    }

    public async Task DeletePostAsync(int id)
    {
        var post = await _context.Posts.FindAsync(id);
        if (post != null)
        {
            _context.Posts.Remove(post);
            await _context.SaveChangesAsync();
        }
    }
}

public class CommentRepository : ICommentRepository
{
    private readonly BlogDbContext _context;

    public CommentRepository(BlogDbContext context)
    {
        _context = context;
    }

    public async Task<IEnumerable<Comment>> GetCommentsForPostAsync(int postId)
    {
        return await _context.Comments
            .Where(c => c.PostId == postId)
            .ToListAsync();
    }

    public async Task AddCommentAsync(Comment comment)
    {
        await _context.Comments.AddAsync(comment);
        await _context.SaveChangesAsync();
    }

    public async Task DeleteCommentAsync(int id)
    {
        var comment = await _context.Comments.FindAsync(id);
        if (comment != null)
        {
            _context.Comments.Remove(comment);
            await _context.SaveChangesAsync();
        }
    }
}

Step 4: Register Repositories in Dependency Injection

public void ConfigureServices(IServiceCollection services)
{
    // Other configurations...

    services.AddDbContext<BlogDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

    services.AddScoped<IPostRepository, PostRepository>();
    services.AddScoped<ICommentRepository, CommentRepository>();

    // Other configurations...
}

Step 5: Use Repositories in Controllers

[ApiController]
[Route("api/posts")]
public class PostController : ControllerBase
{
    private readonly IPostRepository _postRepository;

    public PostController(IPostRepository postRepository)
    {
        _postRepository = postRepository;
    }

    // GET: api/posts
    [HttpGet]
    public async Task<ActionResult<IEnumerable<Post>>> GetAllPosts()
    {
        var posts = await _postRepository.GetAllPostsAsync();
        return Ok(posts);
    }

    // GET: api/posts/{id}
    [HttpGet("{id}")]
    public async Task<ActionResult<Post>> GetPostById(int id)
    {
        var post = await _postRepository.GetPostByIdAsync(id);
        if (post == null)
        {
            return NotFound();
        }
        return Ok(post);
    }

    // POST: api/posts
    [HttpPost]
    public async Task<ActionResult<Post>> CreatePost(Post post)
    {
        await _postRepository.AddPostAsync(post);
        return CreatedAtAction(nameof(GetPostById), new { id = post.Id }, post);
    }

    // PUT: api/posts/{id}
    [HttpPut("{id}")]
    public async Task<IActionResult> UpdatePost(int id, Post post)
    {
        if (id != post.Id)
        {
            return BadRequest();
        }

        await _postRepository.UpdatePostAsync(post);
        return NoContent();
    }

    // DELETE: api/posts/{id}
    [HttpDelete("{id}")]
    public async Task<IActionResult> DeletePost(int id)
    {
        await _postRepository.DeletePostAsync(id);
        return NoContent();
    }
}

Conclusion

The Repository Pattern in C# .NET Core offers a structured approach to managing data access, promoting modularity, maintainability, and testability in your applications. By encapsulating data access logic in repositories, you can easily switch between different data sources or ORM frameworks without affecting the rest of your application’s business logic. This pattern is particularly useful in large-scale applications where data access is a significant concern.

In this blog post, we’ve covered the basics of the Repository Pattern, its benefits, and provided a practical implementation example using C# .NET Core for a blog application. Whether you’re building a new application or refactoring an existing one, consider adopting the Repository Pattern to streamline your data access layer and improve overall code quality.

About Post Author

Vicky Chhetri

developer@vickychhetri.com

https://vickychhetri.com/

Happy

0 0 %

Sad

0 0 %

Excited

0 0 %

Sleepy

0 0 %

Angry

0 0 %

Surprise

0 0 %

About Author

Vicky Chhetri

See author's posts