Practical NET And Software Architecture Tips

You Should Know:

AutoMapper: A popular object-to-object mapping library in .NET. It helps in reducing the boilerplate code for mapping properties between objects.

// Example of AutoMapper configuration
var config = new MapperConfiguration(cfg => cfg.CreateMap<Source, Destination>());
var mapper = config.CreateMapper();
var destination = mapper.Map<Destination>(source);

Entity Framework Core (EF Core): A lightweight, extensible, and cross-platform version of Entity Framework. It is used for database interactions in .NET applications.

// Example of EF Core query
using (var context = new MyDbContext())
{
var blogs = context.Blogs
.Where(b => b.Url.Contains("dotnet"))
.ToList();
}

Dapper: A simple object mapper for .NET. It is known for its performance and ease of use, especially when dealing with raw SQL queries.

// Example of Dapper query
using (var connection = new SqlConnection(connectionString))
{
var sql = "SELECT * FROM Blogs WHERE Url LIKE @Url";
var blogs = connection.Query<Blog>(sql, new { Url = "%dotnet%" });
}

Clean Architecture: A design philosophy that separates the application into layers, ensuring that the business logic is independent of the UI, database, and other external concerns.

// Example of Clean Architecture layers
// Domain Layer
public class Blog
{
public int Id { get; set; }
public string Url { get; set; }
}

// Application Layer
public class BlogService
{
private readonly IBlogRepository _blogRepository;

public BlogService(IBlogRepository blogRepository)
{
_blogRepository = blogRepository;
}

public IEnumerable<Blog> GetBlogsByUrl(string url)
{
return _blogRepository.GetBlogsByUrl(url);
}
}

// Infrastructure Layer
public class BlogRepository : IBlogRepository
{
private readonly MyDbContext _context;

public BlogRepository(MyDbContext context)
{
_context = context;
}

public IEnumerable<Blog> GetBlogsByUrl(string url)
{
return _context.Blogs.Where(b => b.Url.Contains(url)).ToList();
}
}

CQRS (Command Query Responsibility Segregation): A pattern that separates read and write operations into different models, improving scalability and performance.

// Example of CQRS implementation
// Command
public class CreateBlogCommand : IRequest<int>
{
public string Url { get; set; }
}

public class CreateBlogCommandHandler : IRequestHandler<CreateBlogCommand, int>
{
private readonly MyDbContext _context;

public CreateBlogCommandHandler(MyDbContext context)
{
_context = context;
}

public async Task<int> Handle(CreateBlogCommand request, CancellationToken cancellationToken)
{
var blog = new Blog { Url = request.Url };
_context.Blogs.Add(blog);
await _context.SaveChangesAsync(cancellationToken);
return blog.Id;
}
}

// Query
public class GetBlogsQuery : IRequest<IEnumerable<Blog>>
{
public string Url { get; set; }
}

public class GetBlogsQueryHandler : IRequestHandler<GetBlogsQuery, IEnumerable<Blog>>
{
private readonly MyDbContext _context;

public GetBlogsQueryHandler(MyDbContext context)
{
_context = context;
}

public async Task<IEnumerable<Blog>> Handle(GetBlogsQuery request, CancellationToken cancellationToken)
{
return await _context.Blogs
.Where(b => b.Url.Contains(request.Url))
.ToListAsync(cancellationToken);
}
}

MediatR: A library that helps in implementing the mediator pattern in .NET applications, often used in conjunction with CQRS.

// Example of MediatR usage
public class BlogController : ControllerBase
{
private readonly IMediator _mediator;

public BlogController(IMediator mediator)
{
_mediator = mediator;
}

[HttpPost]
public async Task<IActionResult> CreateBlog([FromBody] CreateBlogCommand command)
{
var blogId = await _mediator.Send(command);
return Ok(blogId);
}

[HttpGet]
public async Task<IActionResult> GetBlogs([FromQuery] GetBlogsQuery query)
{
var blogs = await _mediator.Send(query);
return Ok(blogs);
}
}

What Undercode Say:

The article provides a comprehensive overview of various tools and architectural patterns used in .NET development. AutoMapper, EF Core, Dapper, Clean Architecture, CQRS, and MediatR are essential components for building scalable and maintainable .NET applications. By leveraging these tools and patterns, developers can streamline their workflows, improve code quality, and enhance application performance. Whether you’re working on a small project or a large enterprise application, these practices will help you achieve a robust and efficient software architecture.

For further reading, you can explore the official documentation of AutoMapper, EF Core, Dapper, and MediatR.