Architectures that we can use with .NET

What's the real difference between Hexagonal, Onion, and Clean Architecture? Learn how to choose the right pattern for your next .NET application.

#1about 2 minutes

The role of an architect and the need for architecture

Good software architecture is essential for creating replaceable, testable, and stable solutions that are easy for new developers to understand.

#2about 1 minute

Understanding the classic layered architecture pattern

The layered architecture, common in legacy systems, separates concerns effectively but often leads to repetitive code across its different layers.

#3about 2 minutes

Exploring data context interaction and the east coast approach

The Data Context Interaction (DCI) architecture focuses on sequences of tasks and introduces the "East Coast approach" where data objects contain their own operational logic.

#4about 2 minutes

The boundary control entity (BCE) architecture pattern

The BCE pattern, a precursor to Clean Architecture, organizes logic around entities with behavior, boundaries for interfaces, and controls that act as use cases.

#5about 3 minutes

Comparing hexagonal (ports & adapters) and onion architectures

Both hexagonal and onion architectures isolate the application core from external dependencies like databases and UI, with onion architecture adding more explicit internal layers.

#6about 1 minute

Enforcing boundaries with dependency injection and assembly attributes

Use a separate dependency injection project and the `InternalsVisibleTo` attribute to prevent the UI from directly referencing and using the infrastructure layer.

#7about 1 minute

Using command query responsibility segregation (CQRS) selectively

Command Query Responsibility Segregation (CQRS) is a powerful pattern that should be applied only to specific, complex portions of a system, not universally.

#8about 5 minutes

Deconstructing Robert C. Martin's clean architecture

Clean architecture combines principles from hexagonal patterns with screaming architecture and domain-driven design, using presenters to format data for the view.

#9about 1 minute

Microsoft's interpretation and templates for clean architecture

Microsoft's official guidance on clean architecture aligns closely with the onion architecture, emphasizing dependency inversion without the complex interactor-presenter flow.

#10about 1 minute

Using aspect-oriented programming for cross-cutting concerns

Aspect-oriented programming (AOP) allows you to centralize cross-cutting concerns like logging and security using tools like middleware, filters, or interceptors.

#11about 1 minute

Implementing a microkernel architecture with runtime plugins

The microkernel (or plugin) architecture allows for loading and unloading application features at runtime using .NET's `AssemblyLoadContext`.

#12about 2 minutes

Understanding the principles of reactive architecture

Reactive architectures are designed to be responsive, resilient, elastic, and message-driven, enabling systems that can handle failures and varying loads gracefully.

#13about 3 minutes

Solving concurrency challenges with the actor model

The actor model provides a robust framework for building concurrent and fault-tolerant systems by using isolated actors that communicate via messages and are managed by supervisors.

From learning to earning

Jobs that call for the skills explored in this talk.