.NET Engineering Glossary
Essential Concepts Every .NET Developer Should Know
When learning .NET, it’s easy to spend most of your time writing code while overlooking the vocabulary behind modern software engineering.
Terms like DTO, Technical Debt, Idempotency, or Composition over Inheritance appear constantly in documentation, architecture discussions, code reviews, and technical interviews. Understanding these concepts makes it much easier to follow best practices and communicate effectively with other developers.
This guide brings together some of the most common .NET and software engineering terms in one place. Think of it as a practical reference rather than something you need to memorize.
REST API & Web Development
URL Path Versioning
A versioning approach where the API version is included directly in the URL, such as:
/api/v1/products
It’s easy to understand and test, although many teams prefer header-based versioning to keep resource URLs consistent.
HTTP Header Versioning
Instead of changing the URL, the API version is sent through an HTTP header.
This keeps endpoints cleaner while allowing multiple API versions to coexist without changing resource paths.
DTO (Data Transfer Object)
A DTO is a lightweight object whose only purpose is transferring data between the server and the client.
Instead of exposing database entities directly, APIs usually return DTOs to hide internal implementation details, improve security, and send only the data the client actually needs.
Stateless
HTTP is a stateless protocol.
Every request contains all the information needed to process it because the server doesn’t automatically remember previous requests.
Idempotency
An HTTP operation is idempotent when executing the same request multiple times produces the same final result.
For example:
GET
PUT
DELETE
are idempotent, while POST usually is not.
ETag
An ETag represents a specific version of a resource.
It helps prevent users from accidentally overwriting someone else’s changes when multiple people update the same data simultaneously.
Testing
Test-Driven Development (TDD)
TDD is a development approach where tests are written before production code.
It follows three simple steps:
Write a failing test.
Write just enough code to make it pass.
Improve the code without breaking the test.
This process is commonly known as Red → Green → Refactor.
Test Pyramid
The Test Pyramid suggests that a healthy test suite should contain:
Many Unit Tests
Fewer Integration Tests
Very few End-to-End Tests
This balance provides fast feedback while keeping maintenance costs low.
AAA (Arrange, Act, Assert)
A simple structure for writing readable tests.
Arrange: Prepare the test data.
Act: Execute the operation.
Assert: Verify the expected result.
White-box Testing
Tests are designed with knowledge of the application’s internal implementation.
Developers typically use this approach for unit testing.
Black-box Testing
The tester focuses only on inputs and outputs without knowing how the application is implemented internally.
Grey-box Testing
A combination of White-box and Black-box testing.
The tester understands part of the internal implementation while still validating the system from the outside.
Boundary Value Analysis
Instead of testing every possible input, this technique focuses on values near the boundaries, where defects are most likely to appear.
For example, if valid input ranges from 1 to 100, you might test:
0
1
2
99
100
101
Fact vs Theory (xUnit)
Fact
A single test with no input parameters.
[Fact]
public void Should_Return_Product()
Theory
A parameterized test executed multiple times using different input values.
[Theory]
[InlineData(1)]
[InlineData(10)]
Fixture
A shared setup object used across multiple tests.
Fixtures reduce duplication and improve test performance by reusing expensive resources such as databases or application hosts.
Software Architecture
Single Responsibility Principle (SRP)
A class should have only one reason to change.
If a class handles unrelated responsibilities, it becomes harder to understand, maintain, and test.
Open/Closed Principle (OCP)
Software should be open for extension but closed for modification.
Instead of changing existing code every time requirements evolve, new behavior should be added through extension points.
Composition over Inheritance
Rather than building deep inheritance hierarchies, modern applications combine smaller components to create flexible behavior.
Composition generally produces systems that are easier to maintain and extend.
Loose Coupling
Components should depend on abstractions instead of concrete implementations.
Lower coupling makes applications easier to modify, test, and scale.
KISS (Keep It Simple, Stupid)
Favor the simplest solution that solves the problem.
Complexity should only be introduced when it provides clear value.
Anti-pattern
A common solution that appears helpful but usually creates maintenance problems over time.
Examples include excessive inheritance or large classes with multiple responsibilities.
God Class
A class that gradually accumulates too many responsibilities.
These classes become difficult to understand, test, and modify, making them one of the most common architectural anti-patterns.
Code Smell
A warning sign that the code may need improvement.
Examples include:
Long methods
Large classes
Duplicate code
Complex conditional logic
A code smell isn’t necessarily a bug, but it often indicates future maintenance issues.
Technical Debt
Technical debt represents shortcuts taken during development to save time.
While sometimes unavoidable, unmanaged technical debt makes future development slower and more expensive.
Refactoring
Refactoring improves the internal structure of code without changing its external behavior.
Its goal is to increase readability, maintainability, and long-term quality.
Modern .NET Development
Record Class
A C# type designed primarily for immutable data.
Records are commonly used for DTOs because they require less code and provide built-in value equality.
Target Framework Moniker (TFM)
A TFM specifies which version of .NET an application targets.
Examples include:
net8.0net9.0
CLI (Command Line Interface)
The .NET CLI provides commands for building, running, testing, and publishing applications.
Examples include:
dotnet build
dotnet run
dotnet test
dotnet publish
Hot Reload
Hot Reload allows developers to apply code changes while the application is still running, reducing the need for full rebuilds during development.
Final Thoughts
Software engineering isn’t just about writing code—it’s also about understanding the language developers use to describe architecture, testing, APIs, and design decisions.
The more familiar you become with these concepts, the easier it becomes to read technical documentation, participate in design discussions, and build software that is easier to maintain over time.
Rather than memorizing every definition, use this glossary as a practical reference whenever you encounter an unfamiliar term.