Publish Date: Jan 10, 2020
This 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
in C# memory management. It explains how the stack, with its
method, stores value types like structs and enums, while the heap handles reference types like
. Key concepts like boxing
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
in C#, addressing the misconception that they always traverse an entire
. It explains the actual behavior of these methods, both with and without a predicate, contrasting them with
. The article clarifies that
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
. It focuses on integrating EventStore into an ASP.NET Core application, highlighted by creating the
class. The tutorial showcases the
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
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
for event handling, illustrated with a
. 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
interface, and handling them with
. 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
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
interface to the implementation of
classes. The article concludes with the
class, demonstrating the pattern’s role in facilitating effective object interaction. Ideal for those interested in applying design patterns in software engineering.