Modern C# Properties: Beyond Getters and Setters

emanuele longo — Fri, 04 Jul 2025 07:23:52 +0000

📝 Full guide published on Medium.

Follow me there for more articles on .NET and C# insights.

Properties in C# are often seen as just a cleaner way to expose fields — but in reality, they’re a powerful abstraction that has evolved significantly over the years.

From simple auto-properties to validation logic, computed values, and advanced patterns for immutability, modern C# (especially the latest versions like C# 9, 11, and 14) offers many capabilities that can make your code safer, clearer, and more maintainable.

Why You Should Care

Here’s why properties deserve more attention:

✅ They protect your domain model with validation rules
✅ They can enforce immutability in a clean, declarative way
✅ They simplify derived/calculated data
✅ They integrate with pattern matching and nullable reference types
✅ They keep APIs clean and self-documenting

And in recent C# releases, properties have gained new features that many developers still underuse, including:

Init-only properties for immutable objects
Required properties to ensure proper initialization
Nullable annotations for safer reference types
Field-backed properties for simpler validation logic
And more improvements coming soon

Curious About All the Latest Features?

I’ve put together a detailed article covering:

What’s changed in properties from C# 9 up to C# 14
Examples of validation, lazy loading, and computed properties
Best practices and patterns you can apply right now
A glimpse into future possibilities, like async properties

If you work with C# and want to write modern, professional, and safe code, this resource will help you level up.

** Thanks for Reading!

Read the full guide on Medium for full context and examples.**

Follow me on Medium for the upcoming insights.

Introduction to Design Patterns with C# .NET: When (and Why) You Should Use Them

emanuele longo — Fri, 27 Jun 2025 09:50:32 +0000

📝 Originally published on Medium.

Follow me there for more articles on .NET and modern software design.

Design patterns are one of the most debated topics in software engineering. Some developers swear by them; others avoid them like the plague. But the truth lies somewhere in the middle: design patterns are powerful tools — when used appropriately.

In the .NET ecosystem, especially with modern C# features and clean architecture practices, understanding when and why to use a pattern is more important than memorizing their structure.

This article is not another reference of the 23 Gang of Four patterns. Instead, we’ll focus on:

What design patterns are in practical terms
When they are actually useful in real-world .NET applications
How to recognize overengineering
Practical examples of patterns in C#
A warning on when not to use them

🎯 What Is a Design Pattern?

A design pattern is a general, reusable solution to a commonly occurring problem in software design. It’s not a finished design or class you can copy-paste, but rather a template on how to solve a problem that can be adapted to your use case.

Design patterns can be classified into several categories:

Creational Patterns
Structural Patterns
Behavioral Patterns
Architectural Patterns
Concurrency Patterns
Integration Patterns
Distribution Patterns
Cloud Design Patterns
Security Patterns

We’ll explore each of these categories in depth over time.

Why and When Should You Use Design Patterns?

Why:

They provide a common language among developers.
Proven solutions refined over years.
Improve maintainability by reducing coupling and separating concerns.
Enable scalability and flexibility (Open/Closed Principle).
Facilitate SOLID principles.

When:

You face a problem that maps directly to a known design pattern.
You need to enforce separation of concerns or loose coupling.
The project is growing in complexity.
You must prepare your codebase for future changes.
You need to vary behaviors dynamically at runtime.

Remember: not everything needs a pattern. Sometimes, a simple method or lambda expression is enough.

Thanks for Reading!

Read the original article on Medium for full context and more examples.

Follow me on Medium for the upcoming series exploring each design pattern category in detail.