Publish Date: Jan 10, 2020This article in the C# garbage collector series outlines the history and types of GC in .NET. It covers three GC modes:
- Server GC for server-side applications
- Concurrent Workstation GC for client apps with UI
- Non-Concurrent Workstation GC for single-processor server apps
Each mode is optimized for different scenarios, balancing throughput and responsiveness. The article provides insights into configuring these modes for specific applications, highlighting the importance of choosing the right GC mode based on the application's nature and environment.
Publish Date: Dec 12, 2019
This article delves into the distinction between
Stack and
Heap in C# memory management. It explains how the stack, with its
LIFO
method, stores value types like structs and enums, while the heap handles reference types like
strings
. Key concepts like
boxing and
unboxing are covered, showing how value types can be converted to reference types and vice versa. The article emphasizes the importance of efficient memory management and the role of the garbage collector in .NET, particularly in managing heap memory and optimizing overall application performance.
Publish Date: Nov 29, 2019
This article explores memory management in C# and the garbage collector’s role. It differentiates
managed languages like C# from
unmanaged ones like C and C++, highlighting C#’s automatic memory management. Using a simple example, the article shows how C# frees developers from the complexities of manual memory allocation and disposal, allowing them to focus more on business logic. The series aims to provide a comprehensive understanding of the garbage collector in C#, demonstrating its efficiency in managing memory in managed programming environments.
Publish Date: Oct 16, 2019
This article demystifies the LINQ methods
Single
and
SingleOrDefault
in C#, addressing the misconception that they always traverse an entire
Enumerable
. It explains the actual behavior of these methods, both with and without a predicate, contrasting them with
First
and
FirstOrDefault
. The article clarifies that
SingleOrDefault
efficiently handles different scenarios, such as returning a default value, the only item, or throwing an error when multiple items exist. It emphasizes the operational differences and efficiency
O(1) without predicate and
O(N) with predicate of these methods, offering valuable insights for C# developers seeking to optimize their code.
Publish Date: Feb 24, 2019
Part 5 of the CQRS with MediatR series introduces
Event Sourcing using
EventStore. It focuses on integrating EventStore into an ASP.NET Core application, highlighted by creating the
EventStoreDbContext
class. The tutorial showcases the
EventLoggerBehavior
in MediatR for logging Command actions and responses, utilizing a
Convention over Configuration approach. This part provides a practical guide for effectively tracking and understanding system state changes in a CQRS application through event history.
Publish Date: Feb 11, 2019
In this part of the CQRS with MediatR series,
behaviors in MediatR are introduced for
aspect-oriented programming. The tutorial covers two specific behaviors:
Performance counter behavior: for logging method execution times.Transaction behavior: for managing database transactions and rollbacks.Both are implemented using the
IPipelineBehavior
interface, demonstrating how to write reusable, efficient code that adheres to the
DRY principle. The article provides practical examples and code snippets, showing how these behaviors enhance functionality and error handling in an ASP.NET Core application.
Publish Date: Feb 2, 2019
Part 3 of the CQRS with MediatR series focuses on adding validation and event handling. Fluent Validation is introduced to validate commands, followed by the use of
INotification
and
INotificationHandler
for event handling, illustrated with a
CustomerCreatedEvent
. This setup allows for separate event handlers for different actions like email notifications and logging, adhering to the
Single Responsibility Principle. The tutorial provides code examples for integrating these features into an ASP.NET Core application, setting the stage for the next part on MediatR behaviors and aspect-oriented programming.
Publish Date: Jan 27, 2019
Discover the practical implementation of the CQRS pattern using MediatR in ASP.NET Core. This tutorial guides you through setting up MediatR, creating commands and queries with the
IRequest
interface, and handling them with
IRequestHandler
. It features a real-world example of adding a customer to a database, showcasing command creation, immutability, and the use of Entity Framework and AutoMapper. The article emphasizes decoupling in request handling, aligning with the
Hollywood Principle, and provides a glimpse into future topics like Fluent Validation. A must-read for developers looking to enhance their CQRS skills.
Publish Date: Jan 21, 2019
This article dives into the implementation of the
CQRS design pattern using the MediatR library in .NET, simplifying its complexity. It explains the division of application methods into
Command
and
Query
functions, highlighting the benefits of this separation for technology choice and scalability. The piece also touches on the concept of events and
Event Sourcing, showcasing their roles in maintaining system states and facilitating troubleshooting. The use of the
Event Store database for implementing Event Sourcing is briefly introduced, offering a comprehensive view of the CQRS pattern and its practical application.
Publish Date: Jan 19, 2019
Explore the Mediator design pattern, illustrated through an airport control tower analogy. Learn how it manages communications between planes in
C#, starting from the
IAirTrafficControl
interface to the implementation of
AirbusAirplane
and
BoeingAirplane
classes. The article concludes with the
JFKAirTrafficControl
class, demonstrating the pattern’s role in facilitating effective object interaction. Ideal for those interested in applying design patterns in software engineering.