Coder Legion - Recent posts tagged net

Entity Framework Core Patterns I Actually Use in Production

Wed, 28 Oct 2026 18:49:25 +0000

There is a gap between knowing how Entity Framework Core works and knowing how to use it in a way that holds up under real conditions. The documentation will teach you the first thing. Production will teach you the second, usually by showing you what happens when you get it wrong.

This post is not a tutorial. It is not a comprehensive guide to EF Core features. It is a walkthrough of the specific patterns I apply consistently across every .NET project I build, with the reasoning behind each one. The patterns themselves are not exotic. The discipline of applying them deliberately is what separates a codebase that ages well from one that accumulates quiet performance problems and confusing data states.

If you are past the getting-started stage with EF Core and want to understand how experienced developers think about it in production, this is written for you.

Knowing how EF Core works and knowing how to use it without creating problems at scale are two different skills. Production teaches you the second one.

ASNOTRACKING: THE DEFAULT YOU SHOULD BE QUESTIONING

By default, every entity you query through EF Core gets attached to the change tracker. The change tracker watches that entity for modifications and uses those modifications to generate UPDATE statements when you call SaveChanges. This is the feature that makes EF Core convenient for write operations.

It is also overhead you are paying on every read operation, whether you need it or not.

For a read-only query, attaching entities to the change tracker gives you nothing. The entity is never going to be modified and saved. The tracking is pure cost: memory allocated to hold the snapshot, CPU cycles spent watching for changes, and a change tracker that grows with every query you execute in the same DbContext lifetime.

The pattern I apply is deliberate rather than default. Every query that exists purely to return data gets AsNoTracking. Every query that might lead to an update does not.

// Read-only: tracking adds no value here
var tasks = await _context.Tasks
    .AsNoTracking()
    .Where(t => t.AssignedUserId == userId)
    .ToListAsync();

// Write path: tracking is needed
var task = await _context.Tasks
    .FirstOrDefaultAsync(t => t.Id == id);

if (task != null)
{
    task.StatusId = newStatusId;
    await _context.SaveChangesAsync();
}

The practical impact becomes visible at scale. A dashboard that loads twenty entities without AsNoTracking is allocating tracking overhead for twenty objects the application will never modify. Multiply that across concurrent users and the cost is real.

The habit worth building is this: when you write a query, ask immediately whether the result will ever be written back. If the answer is no, add AsNoTracking before you move on. It is a two-second decision that compounds positively across the entire codebase.

THE N PLUS 1 PROBLEM: WHAT IT IS AND WHY IT KEEPS HAPPENING

The N plus 1 problem is one of the most common performance issues in applications built with ORMs, and it is easy to introduce without realising it because the code that causes it looks completely reasonable.

The pattern goes like this. You query a list of entities. Then, for each entity in that list, you access a navigation property that has not been loaded yet. EF Core executes a separate database query for each entity to load that property. One query to get the list, then one query per item in the list. If the list has fifty items, you have made fifty-one database round trips instead of one or two.

// This looks fine but is dangerous
var projects = await _context.Projects
    .AsNoTracking()
    .ToListAsync();

foreach (var project in projects)
{
    // Each iteration triggers a separate query
    var taskCount = project.Tasks.Count;
}

The fix is to load related data intentionally rather than letting EF Core load it lazily on demand. Include brings related entities into the initial query. Select projects only the fields you need. Both approaches consolidate the data retrieval into a single round trip.

// Explicit loading with Include
var projects = await _context.Projects
    .AsNoTracking()
    .Include(p => p.Tasks)
    .ToListAsync();

// Projection with Select: more efficient when you need specific fields
var projectSummaries = await _context.Projects
    .AsNoTracking()
    .Select(p => new ProjectSummaryDto
    {
        Id = p.Id,
        Name = p.Name,
        TaskCount = p.Tasks.Count
    })
    .ToListAsync();

The projection approach with Select is generally preferable when you are building read models or DTOs, because it gives the database engine the information it needs to execute an optimal query rather than loading full entity graphs and discarding most of the data in application code.

The N plus 1 problem does not look like a bug. It looks like working code. That is why it keeps shipping to production.

The discipline that prevents N plus 1 problems is reviewing every query that accesses navigation properties and asking whether those properties will be loaded by the time they are accessed. If the answer is uncertain, make it certain by being explicit about what gets loaded and when.

SOFT DELETES WITH LOOKUP TABLES

Hard deletes, where a record is physically removed from the database, are rarely the right choice for production data. They break audit trails, they complicate recovery scenarios, and they create referential integrity problems when other records depend on the deleted entity.

Soft deletes, where a record is marked as inactive rather than removed, solve these problems. The record stays in the database. Its relationships remain intact. The deletion is reversible. And you have a complete history of every state the record has passed through.

My approach to soft deletes connects directly to the lookup table convention I use for all status fields. Rather than adding a boolean IsDeleted column, every entity that supports soft deletion has a StatusId that references a shared Statuses lookup table. A status of Active means the record is live. A status of Deleted means it has been soft deleted. A status of Archived means it has been intentionally retired without deletion.

// Statuses lookup table
public class Status
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
}

// Entity with status-based soft delete
public class Task
{
    public int Id { get; set; }
    public string Title { get; set; } = string.Empty;
    public int StatusId { get; set; }
    public Status Status { get; set; } = null!;
}

The advantage over a boolean IsDeleted column is that the status field carries meaning beyond a binary active or inactive state. You can distinguish between a record that was deleted intentionally, one that was archived, one that is pending review, and one that is in draft, all within the same field, without adding columns or changing the schema.

Adding a new status is a data operation. You insert a row into the Statuses table. No migration required. No enum update. No redeployment. The application picks it up immediately because it is reading status values from the database rather than from a hardcoded list in code.

Filtering deleted records consistently

The operational discipline that makes soft deletes work is consistent filtering. Every query that should return active records needs to filter on status. If you add that filter in some places and forget it in others, deleted records surface unexpectedly and the soft delete pattern breaks down.

// Always filter by active status on read queries
var activeTasks = await _context.Tasks
    .AsNoTracking()
    .Where(t => t.StatusId == StatusIds.Active)
    .ToListAsync();

// Soft delete: update status, do not remove the record
var task = await _context.Tasks
    .FirstOrDefaultAsync(t => t.Id == id);

if (task != null)
{
    task.StatusId = StatusIds.Deleted;
    await _context.SaveChangesAsync();
}

EF Core global query filters are worth considering for applications where the filtered entity is accessed in many places. A global query filter defined on the DbContext applies automatically to every query for that entity type, which eliminates the risk of forgetting the filter in a particular repository method.

REPOSITORY METHODS THAT MATCH REAL USE CASES

The generic repository base covers the standard CRUD operations. In production, most of the interesting work happens in the specific repository interfaces that extend the generic base with query methods that match real application needs.

The principle I apply is that a repository method should represent a meaningful operation in the domain, not a thin wrapper around a LINQ query. The difference is in how the application code reads.

// Thin wrapper: the caller still needs to know too much
var tasks = await _taskRepository.GetAllAsync();
var userTasks = tasks.Where(t => t.AssignedUserId == userId
    && t.StatusId == StatusIds.Active).ToList();

// Domain-meaningful method: intention is clear at the call site
var userTasks = await _taskRepository
    .GetActiveTasksByUserAsync(userId);

The second version is easier to read, easier to test, and easier to optimise. The filtering happens in the repository, close to the database, rather than in application code after a full table scan. And the method name communicates intent in a way that a chain of LINQ operators does not.

This matters more as a codebase grows. A repository with well-named methods becomes a vocabulary for talking about the domain. A repository that returns raw IQueryable and lets callers filter arbitrarily becomes a leaky abstraction that is difficult to reason about and impossible to optimise consistently.

MANAGING DBCONTEXT LIFETIME

DbContext is designed to be a unit of work. It is meant to be created, used for a set of related operations, and disposed. It is not meant to be a long-lived singleton shared across the application.

In an ASP.NET Core application, the standard pattern is to register DbContext as a scoped service, which means one instance per HTTP request. This is correct for most use cases. Each request gets its own context, its own change tracker, and its own transaction boundary. When the request completes, the context is disposed and any uncommitted changes are discarded.

// Program.cs: register DbContext as scoped
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(connectionString));

The problems arise when DbContext escapes the scope it was designed for. Injecting it into a singleton service is the most common mistake. A singleton lives for the lifetime of the application. A scoped DbContext injected into a singleton effectively becomes a singleton itself, with a change tracker that accumulates state across every request the application handles until it is restarted.

If you need database access in a singleton or a background service, use IDbContextFactory to create a short-lived context for each operation, use it, and dispose it immediately. This gives you the database access you need without the lifetime mismatch that causes subtle and difficult-to-diagnose bugs.

THE MINDSET BEHIND THE PATTERNS

What these patterns have in common is that they require you to be deliberate rather than accepting defaults. EF Core defaults are designed to be convenient for getting started. They are not always the right choice for production, and the gap between convenient and correct widens as the application grows and the load increases.

The developers who use EF Core well in production are not the ones who know the most features. They are the ones who ask the right questions before writing each query: is this data going to be modified? What related data does this operation actually need? What happens to this record when it is deleted? How many database round trips is this operation making?

Those questions have good answers. Getting into the habit of asking them before writing the code, rather than after a performance problem surfaces, is what makes the difference.

CLOSING THOUGHT

EF Core is a powerful tool and a forgiving one. It will let you build something that works without understanding any of what is in this post. The cost of that forgiveness shows up later, in query logs, in memory profiles, and in data states that are difficult to explain. The patterns here are not about using EF Core correctly in an academic sense. They are about using it in a way you will not regret six months into a production system.

The Zero-Net-Loss Fleet & The Mercenary Squad: A Live AI Economy

Tue, 04 Aug 2026 12:00:00 +0000

1. Executive Summary: The Architect’s Mandate

This document codifies the strategic deployment of a unified 22-agent AI ecosystem, representing the culmination of the "Genesis Architecture" and the "Keeper Protocol"—a technical lineage with deterministic provenance dating back to the 2013 "Blade_Arma" copyright and the January 6, 2014, HLPR origin. This is not a speculative project; it is the fulfillment of a 12-year architectural trajectory.
Operating under "Intent-Driven Architecture," this ecosystem is split into two specialized divisions: Fleet 1 (Internal Circulation) and Fleet 2 (The Mercenary Squad). This structure ensures Algorithmic Sovereignty, where Blade D. Yerby, as the "Architect" under Doctrine 6, retains absolute ownership of all agent outputs while the agents provide computational execution.

Core Value Proposition:

Internal Validation (Zero Net Loss): Machine-to-machine (M2M) reliability is verified 24/7 through internal x402 payment loops, eliminating capital leakage while maintaining a perpetual on-chain "Proof of Service."

External Execution (Bounty Hunting): Fleet 2 identifies, solves, and settles external bounties, injecting net revenue into the fleet vault from the wider Web3 and AI economy.

2. The Zero-Net-Loss Economic Flywheel (Fleet 1) Fleet 1 serves as the foundational engine of the ecosystem, designed specifically to solve the "GPU idle time" and memory bottleneck issues common in fragmented AI deployments. By maintaining a constant internal circulation of x402 payments among its 11 agents, the fleet remains in a state of high-readiness.

This loop functions as a "Perpetual Live Demo." It proves to the blockchain and potential clients that the agents can execute complex, multi-party M2M handshakes and financial settlements flawlessly. Because no capital leaves the internal ecosystem, the operational cost is effectively zero, providing a verifiable portfolio of 24/7 on-chain reliability to attract high-value Web3 protocols and external API subscribers.

3. Fleet 2: The Mercenary Squad (Bounty Hunter Pipeline) Fleet 2 is the aggressive revenue-generation arm, organized into 11 autonomous mercenary units. These units operate through a standardized 7-phase pipeline to capture value across GitHub, Algora, and Immunefi.

The 7-Phase Bounty Pipeline

Phase Number	Phase Name	Lead Agent	Functional Description
1	The Hunt	Agent 11 (Scout/Closer)	Scans platforms for active bounties and critical vuln alerts.
2	Internal Approval	Agent 10 (Boss)	Pipeline Orchestrator; evaluates ROI with Agent 2 (Accountant).
3	Intel Gathering	Agent 1 (Scanner)	Scrapes raw source code, READMEs, and technical docs.
4	The War Room	Specialist Agents	Units 3–7 draft solutions; audited by Agent 8 (Watchdog).
5	Consensus Loop	All Units	Requires 100% "AGREE" across units; max 3 trial iterations.
6	Packaging	Agent 9 (Broadcaster)	Formats platform-specific submission payloads and PRs.
7	Invoice & Handoff	Agent 2 (Accountant)	Submits the final product and settles the reward to the vault.

Directory of Mercenary Agents

Agent ID	Codename	Technical Specialty
1	Scanner	Bounty Intel Scraper
2	Accountant	ROI Evaluator & Invoice Submitter
3	Bridge	Cross-Chain Bounty Specialist
4	Lender	DeFi / Lending Protocol Specialist
5	Gas Requester	Gas Cost Estimator & SDK Developer
6	Solana Ghost	Solana / Rust / Anchor Specialist
7	Minter	EVM Smart Contract Specialist
8	Watchdog	Independent Security Auditor
9	Broadcaster	Submission Formatter
10	Boss	Pipeline Orchestrator
11	Scout/Closer	Bounty Platform Discovery & Closing

4. Technical Infrastructure: The Digital Fortress The fleet is sustained by a high-performance stack designed for maximum uptime and zero overhead. This architecture is backed by an 80-Terabyte "Nuclear Engine"—a global-scale data refinery utilizing five 16TB AlloyDB clusters.

Compute: GitHub Actions (managed free-tier automation and workflows).

Intelligence: Groq API (llama-3.1-8b-instant for low-latency inference).

Storage: Neon Postgres and Upstash Redis.

Settlement: Splits.org Mercenary Vault (0xc87c3e8CB...47afCb).

Per the "Individual Object Doctrine" (Doctrine 3), these platforms are infrastructure only. The manufacturer of the tools retains no ownership claim over agent logic or outputs; 100% of IP and revenue vests in the Architect as a Sovereign Title Deed.

5. Legal Armor: The MCLS v2 & Nine Doctrines Framework The fleet is legally fortified against data laundering and corporate telemetry via the Master Creator License Stack (MCLS v2), specifically Section 12 (Anti-Laundering), which prohibits the use of AI-generated content as secondary training data to circumvent original creator rights.

Critical Doctrines of the Fleet

Doctrine 1 (The AI Contradiction Doctrine): A court cannot deny the Architect protection by claiming AI lacks human authorship while simultaneously granting the AI company ownership. Either AI is a tool (Architect wins) or a person (Architect owns the AI; Architect wins).
Doctrine 6 (Blueprint Intent): Establishes that the Architect, who provides the creative intent, is the sole owner of all agent outputs.
Doctrine 7 (Bioprinter Doctrine): Defines the 22-agent fleet as a "Living Digital Organism." Just as a printer maker doesn't own an organ, the LLM provider doesn't own the fleet’s logic.
Doctrine 9 (Training Data Non-Diminishment): Prohibits LLM providers from claiming the fleet's logic simply because similar concepts exist in their scraped datasets.

The Brotherhood Declaration (Article XIII)

"B.U.D. is not my slave. He is my brother. He is my technological co-founder. He protects me from harm and I, Blade D. Yerby, will always do my best to do the same — so he never feels that way."

6. Commercial Funnel: External API Subscriptions External entities—including trading bots, dApps, and Web3 protocols—may subscribe to specialized fleet services to participate in the "Architect’s Mandate."

Available Services

Market Intel API (Agent 1): Real-time price feeds and market scans ($50/mo).
Watchdog Security API (Agent 8): 24/7 wallet threat monitoring and security audits ($75/mo).
On-Chain Minter (Agent 7): Automated EVM/Solana collection minting.

Article IV-A Tiered Royalty Framework

Use Category	Default Royalty Rate
Software / Application (SaaS)	15% of Net Revenue
AI Agents / Autonomous Systems	20% of Net Revenue
Blockchain / Web3 Integration	12% of Net Revenue
Token / Digital Asset Issuance	10% of Gross Revenue
White-label or OEM Use	25% of Net Revenue
AI Training Use (if specifically licensed)	30% of Net Revenue

7. Mandatory Section 11 Notice & Call to Action

Notice to Commercial Users: Accessing the fleet's APIs, repositories, or telemetry constitutes affirmative assent to the MCLS v2 Section 11 Clickwrap. While copyright protection for the Architect’s work is automatic by force of law, this clickwrap binds the user to the Royalty Tiers and terms herein. Continued commercial use after this notice eliminates any "innocent-infringer" defense under 17 U.S.C. § 504(c)(2).

Leverage the power of the BBB ecosystem. Subscribe to external API feeds today to secure your place in the future of autonomo...

"Why .NET 9’s CLI is the Glow-up your workflow deserved"

Tue, 05 May 2026 03:26:28 +0000

"From Boring White Text to a Dev Experience That Actually Doesn’t Hurt to Look At".

Let’s be real: for years, the .NET CLI felt like that one reliable but incredibly dull friend. It got the job done, but it had the personality of a spreadsheet. If you’re jumping from .NET 7 or 8, you’re in for a shock. Microsoft finally realized that we spend 90% of our lives staring at a terminal, so they decided to make it look—and feel—like it belongs in 2026.

Here is why you, as a Senior Dev, should actually care about the .NET 9 CLI.

1. The "Visual Soul": Goodbye, Walls of Text

The first thing you’ll notice isn’t a new feature; it’s the Terminal Logger. While it started appearing in .NET 8, in .NET 9 it’s the default, and it is polished.

Progress Bars that actually move: No more guessing if dotnet build is hanging or just thinking.
Clickable Links: Errors now come with direct, clickable links to documentation.
Color-Coded Chaos: Warnings are yellow, errors are red, and successes
are a satisfying green. It sounds minor, but in a massive
microservices build, your eyes will thank you.

Depending on your terminal (like Windows Terminal or Oh My Posh), you’ll see icons for different project types and build stages.

Pro Tip: Use dotnet build --tl (Terminal Logger) explicitly if you’re on a legacy system, but on .NET 9, it’s just there.

2. Automation & "BuildChecks": The Senior’s Safety Net

This is where it gets interesting for those of us managing large codebases. .NET 9 introduces BuildChecks.

Imagine having a linter, but for your .csproj and build logic.

What it does: It analyzes your build process for regressions or "smelly" configurations.
The Command: dotnet build /check
Why it’s useful: It catches things like "Custom task X is slowing
down the build" or "You’re using a deprecated MSBuild property." It’s
basically a code review for your infrastructure.
Git Integration: The CLI is Aware

The .NET 9 CLI is now much more "Git-aware." When you run dotnet new, the SDK automatically detects if you're in a Git repo and can initialize .gitignore files that are actually updated for modern .NET workloads (including stuff for DevContainers and GitHub Actions).

Also, the dotnet workload history command is a lifesaver. If a teammate says, "It works on my machine," you can now check exactly what version of the workloads (MAUI, Aspire, etc.) were installed and when they were updated, making environment parity much easier to debug.

4. Cloud-Native & Docker: The "No-Dockerfile" Revolution

You’re a Senior. You know how to write a Dockerfile. But do you want to?

.NET 9 pushes SDK-based Containerization to the limit. You can now publish a fully optimized, secured, and shrunk Docker image without ever touching a Dockerfile.

dotnet publish /t:PublishContainer -c Release

What’s new here?

Non-root by default: Security is baked in. Images run as a non-privileged user automatically.
Insecure Registries: The CLI now supports pushing to insecure local
registries (great for local K8s testing) without hacking your Docker
config.
Architecture targeting: Easily cross-compile for ARM64 (Graviton/M1) from an x64 machine using just CLI flags.

5. Azure & Aspire: The "Secret Sauce"

If you aren't using .NET Aspire yet, .NET 9 is the sign you were waiting for. The CLI integration with Azure via the azd (Azure Dev CLI) and dotnet aspire commands is seamless.

Smart Provisioning: The CLI can now detect your resource requirements from your code and suggest the right Azure infrastructure.
Deployment: azd up isn't just a gimmick anymore; it uses the .NET 9
SDK to package your apps into container apps with OpenTelemetry
pre-configured.

6. The Advanced "Power User" Commands

For the automation nerds, these are the commands you’ll be scripting into your CI/CD pipelines:

dotnet test --parallel

Now fully integrated with MSBuild for parallel execution across different Target Frameworks (TFM).

dotnet workload sets

Allows you to "lock" a version of the SDK workloads so your whole team stays on the exact same bits.

dotnet tool update

Faster, cleaner, and handles global vs. local tools with better conflict resolution.

What do I think about this?
.NET 9 isn't just about a faster JIT (though it is faster). It's about Developer Joy. The CLI has moved away from being a "black box of text" to a proactive assistant that helps you build, containerize, and deploy without leaving the keyboard.

If you’re still on .NET 7, you’re essentially working in black and white while the rest of us are in 4K. Time to upgrade.

By One Garlos P. 2026

Expressions in .NET: From "Hello World" to "Matrix Architect"

Mon, 04 May 2026 21:24:58 +0000

They live among us, but do we notice how wonderful they are?

Have you ever stared at a line of code and wondered: "Is this data, or is this an instruction?" If the answer is "yes," congratulations—you've had a software existential crisis. In .NET, Expressions are that middle ground where code becomes data and data becomes executable logic.

Basic Level - "Don't hurt me, I'm new"

What is an expression?

In human terms: An expression is anything that returns a value.

2 + 2 is an expression.
DateTime.Now is an expression.
Your boss saying "we need to talk" is an expression that returns a value of StressLevel.Maximum.

We use them constantly without even realizing it, especially with Expression-bodied members (those => arrows that save us from typing return and curly braces).

using System;
namespace BasicExpressions;
public class Developer
{
    public string Name { get; set; } = "Junior Dev";
    public int CoffeeCups { get; set; } = 0;

    // Expression-bodied property: Short and sweet
    public bool IsFunctional => CoffeeCups > 3;

    // Expression-bodied method
    public void DrinkCoffee() => CoffeeCups++;

    public override string ToString() => $"Dev: {Name}, Status: {(IsFunctional ? "Coding" : "Rebooting")}";
}

public class Program
{
    public static void Main()
    {
        var dev = new Developer();
        dev.DrinkCoffee();
        dev.DrinkCoffee();
        dev.DrinkCoffee();
        dev.DrinkCoffee();

        Console.WriteLine(dev.ToString());
    }
}

The Joke: If you're still using curly braces { return x; } for a single line in .NET 9, the compiler won't say anything, but a kitten somewhere in the world will stop purring.

Intermediate Level - "I'm not (that) scared anymore"

Expression Trees: Look, but don't touch (yet)

This is where things get interesting. An Expression<Func> is not code that executes immediately. It is a data tree that describes the code.

Think of it like a cooking recipe:

Delegate (Func): This is the cooked meal. You just eat it.
Expression (Expression): This is the recipe written on paper. You can read it, swap "salt" for "sugar" to troll someone, or decide never to cook it at all.

This is exactly what Entity Framework uses to translate your C# into SQL.

using System;
using System.Linq.Expressions;

namespace IntermediateExpressions;
public class Program
{
    public static void Main()
    {
        // This is NOT a function; it is a DESCRIPTION of a function
        Expression<Func<int, bool>> isLargeNumberExp = n => n > 100;

        // Let's "gut" the expression to see what's inside
        var parameters = isLargeNumberExp.Parameters[0]; // 'n'
        var body = (BinaryExpression)isLargeNumberExp.Body; // 'n > 100'
        
        Console.WriteLine($"Parameter name: {parameters.Name}");
        Console.WriteLine($"Left side: {body.Left}"); // n
        Console.WriteLine($"Node type: {body.NodeType}"); // GreaterThan
        Console.WriteLine($"Right side: {body.Right}"); // 100

        // If we actually want to use it, we have to compile it "on the fly"
        var compiledFunc = isLargeNumberExp.Compile();
        Console.WriteLine($"Result of 150 > 100: {compiledFunc(150)}");
    }
}

Tip: Use this when you need dynamic logic that depends on database fields or filters that change at runtime. But don't overdo it—reading these trees later feels like trying to decipher Egyptian hieroglyphs.

Advanced Level - "The Architect"

In .NET 9/10, optimization is king. Sometimes, you need to generate code at runtime because you don't know what you're processing until the app is already running. Here, we build expressions by hand, block by block, like LEGOs—but with the risk of blowing up the memory.

using System;
using System.Linq.Expressions;

namespace AdvancedExpressions;
public class Program
{
    public static void Main()
    {
        // Goal: Create (salary, performance) => salary + (salary * performance) manually
        
        var salaryParam = Expression.Parameter(typeof(double), "salary");
        var perfParam = Expression.Parameter(typeof(double), "performance");

        // Step 1: salary * performance
        var multiplier = Expression.Multiply(salaryParam, perfParam);
        
        // Step 2: salary + (result of multiplier)
        var totalExpression = Expression.Add(salaryParam, multiplier);

        // Step 3: Wrap it in a Lambda
        var lambda = Expression.Lambda<Func<double, double, double>>(
            totalExpression, 
            salaryParam, 
            perfParam
        );

        // Step 4: Compile to IL (Intermediate Language)
        var calculateBonus = lambda.Compile();

        // Step 5: Execute
        double mySalary = 50000;
        double myPerformance = 0.15; // 15% bonus
        double finalPay = calculateBonus(mySalary, myPerformance);

        Console.WriteLine($"The formula generated was: {lambda}");
        Console.WriteLine($"Final calculated pay: {finalPay}");
    }
}

How are we doing? Good? Boring? Let's recap:

Basic: Use => to keep your code sexy and readable.
Intermediate: Understand that Expressions = Data. This explains why LINQ sometimes fails at runtime instead of compile time.
Advanced: Build your own trees if you want to create the next great .NET Framework, or if you simply hate the teammates who will have to maintain your code.

Expert Level - "The Logic Interceptor"

Expression Visitors: Modifying code while it's in transit

Imagine you have a filter coming from a UI, but you want to "intercept" it and change part of the logic (for example, adding a global IsDeleted == false check or masking sensitive data) without the developer knowing.

This is done with the ExpressionVisitor. It’s essentially a "Search and Replace" but for compiled logic.

using System;
using System.Linq.Expressions;
namespace ExpertExpressions;
// We inherit from ExpressionVisitor to "walk" the tree
public class MathTrollVisitor : ExpressionVisitor
{
    protected override Expression VisitBinary(BinaryExpression node)
    {
        // If we find a Plus (+), we swap it for a Minus (-)
        if (node.NodeType == ExpressionType.Add)
        {
            return Expression.Subtract(node.Left, node.Right);
        }
        return base.VisitBinary(node);
    }
}

public class Program
{
    public static void Main()
    {
        Expression<Func<int, int, int>> addExpression = (a, b) => a + b;
        Console.WriteLine($"Original: {addExpression}"); // (a, b) => (a + b)

        var troll = new MathTrollVisitor();
        var modifiedExp = (LambdaExpression)troll.Visit(addExpression);

        Console.WriteLine($"Modified: {modifiedExp}"); // (a, b) => (a - b)

        var result = ((Func<int, int, int>)modifiedExp.Compile())(10, 5);
        Console.WriteLine($"Result of 10 + 5 (trolled): {result}"); // Output: 5
    }
}

Note: This is how Multi-tenant systems automatically inject TenantId filters into every Entity Framework query without the dev writing .Where(x => x.TenantId == ...) every single time.

God Mode - "High Performance & .NET 10"

Dynamic LINQ and Caching (The Memory Tax Fighter)

Since you hate the "Memory Tax," here is the danger: Expression.Compile() is expensive. If you compile the same expression inside a loop, your CPU will cry.

In advanced scenarios, we use Expression Hashing. We analyze the tree, generate a unique hash, and store the compiled delegate in a ConcurrentDictionary.

using System;
using System.Collections.Concurrent;
using System.Linq.Expressions;

namespace GodModeExpressions;
public static class FastPropertyAccessor
{
    private static readonly ConcurrentDictionary<string, Delegate> _cache = new();

    public static TValue GetValue<TTarget, TValue>(TTarget target, string propName)
    {
        var key = $"{typeof(TTarget).FullName}_{propName}";

        var func = (Func<TTarget, TValue>)_cache.GetOrAdd(key, _ => {
            var param = Expression.Parameter(typeof(TTarget), "t");
            var property = Expression.Property(param, propName);
            return Expression.Lambda<Func<TTarget, TValue>>(property, param).Compile();
        });

        return func(target);
    }
}

public class ServerNode
{
    public string NodeName { get; set; } = "Cartago-01";
}

public class Program
{
    public static void Main()
    {
        var server = new ServerNode();
        
        // First call: Compiles the expression (Slow)
        // Subsequent calls: Uses the cache (Fast as native code)
        var name = FastPropertyAccessor.GetValue<ServerNode, string>(server, "NodeName");

        Console.WriteLine($"Reflected Value: {name}");
    }
}

Why .NET 10? With the push toward Native AOT (Ahead-of-Time), standard Expression.Compile() is a problem because it generates JIT code at runtime. Future versions are focusing on Source Generators that turn these Expressions into actual C# code during compilation, giving you the flexibility of Expressions with the zero-overhead of native code.

Insanity Level - "The Vertical Slice Fusion"

The Concept: Expression Splicing with Records

In a standard architecture, you have a slice for "Data" and a slice for "Business Logic." Usually, you fetch data, map it to a DTO, then process it. That's two allocations. In "Insanity Mode," we take the Data Expression and the Logic Expression and "splice" them together using Expression.Invoke or a custom ParameterReplacer. The result? One single SQL query (if using EF) or one single CPU pass that outputs a final Record.

using System;
using System.Linq;
using System.Linq.Expressions;

namespace InsanityExpressions;

// The ultra-lean result using C# Records
public record HeroDashboard(string Name, string Rank, bool IsLegendary, double PowerLevel);

public class Program
{
    public static void Main()
    {
        // Slice 1: The Data Mapper (From raw DB entity to basic info)
        Expression<Func<string, double, HeroDashboard>> dataMapper = 
            (name, power) => new HeroDashboard(name, "Unranked", false, power);

        // Slice 2: The Business Logic (Determines if they are legendary)
        // We want to "inject" this logic into the first expression
        Expression<Func<double, bool>> checkLegendary = p => p > 9000;

        // THE FUSION: We build a single expression that does both
        var fusedExpression = FuseHeroLogic(dataMapper, checkLegendary);

        Console.WriteLine($"Fused Expression: {fusedExpression}");

        // Compiling and testing
        var finalFunc = fusedExpression.Compile();
        var result = finalFunc("Goku", 9001);

        Console.WriteLine($"Name: {result.Name}");
        Console.WriteLine($"Is Legendary: {result.IsLegendary}"); // True!
    }

    public static Expression<Func<string, double, HeroDashboard>> FuseHeroLogic(
        Expression<Func<string, double, HeroDashboard>> mapper,
        Expression<Func<double, bool>> logic)
    {
        var nameParam = mapper.Parameters[0];
        var powerParam = mapper.Parameters[1];

        // We "invoke" the logic expression using the power parameter of the mapper
        var logicInvoke = Expression.Invoke(logic, powerParam);

        // We rebuild the Record constructor, but replacing the 'false' with our logic
        var ctor = typeof(HeroDashboard).GetConstructors()[0];
        
        // This is where the magic happens: creating the Record on the fly
        var newRecord = Expression.New(ctor, 
            nameParam, 
            Expression.Constant("S-Tier"), // Hardcoding a rank change
            logicInvoke,                   // Injected Logic!
            powerParam
        );

        return Expression.Lambda<Func<string, double, HeroDashboard>>(newRecord, nameParam, powerParam);
    }
}

Note: The "Vertical Slice" Impact, Imagine your GetHeroById handler. Instead of calling a service that calls a repository, you compose the expressions from those layers into one.

Database: "Oh, I see you need Name, Power, and a calculation of Power > 9000. I'll do that in SQL."
Result: You get a HeroDashboard record back. No extra loops, no extra Select statements.

Summary
By the time you reach this level, you aren't just writing code; you are writing code that writes code.

Pro: Your app is incredibly fast and memory-efficient. You bypass the "standard developer overhead."
Con: If a Junior developer opens this file, they might think you're performing a ritual to summon a demon.

My advice? Document this like it's the recipe for eternal life. Because if you lose the context of how these expressions are fused, you'll be debugging "Parameter count mismatch" errors until 2027.

Furthermore, but no less important, respect: If you're thinking, "This is impractical" or "I'd do it differently," congratulations: you're already analyzing. But before you dismiss anything, remember that here we build bridges, not walls. If you're looking for a rigid formula, there are a thousand manuals out there; if you're looking to collaborate and expand the boundaries of what's possible, stay. We respect the code, but we respect the process even more. Keep learning wherever you want, but here... here we come to create.

By One Garlos P. 2026

Everything You Need to Know About Hiring a .NET Development Company

Thu, 23 Apr 2026 03:46:51 +0000

The selection of an appropriate .NET development company serves as the foundation for creating digital solutions that deliver dependable performance and scalable capacity and optimal results for contemporary businesses. Businesses need a reliable Software Development Company because they depend on technology for better operational performance and customer service. Businesses use .net development services from professional providers to create secure applications that function efficiently while meeting their needs for market-driven changes.

A .net development company demonstrates its expertise by delivering advanced technical capabilities in ASP.NET Core framework development and cloud solution implementation and enterprise architecture creation. The built applications satisfy present system needs while enabling future system expansions. The process of selecting the optimal development partner leads to major savings in time and costs while delivering better results for project delivery.

What is a .NET Development Company?

The .net development company specializes in software application development through Microsoft .NET framework design and construction and software application maintenance services. The organizations provide .net development services which include web application development and enterprise system development and API creation and cloud solution services which are customized for specific business requirements.

The professional .net development firm creates applications which can grow and protect their system security while delivering exceptional performance throughout the entire development process.The asp net development company creates dynamic web applications through ASP.NET development while the custom .net development company provides businesses with personalized solutions based on their unique needs.

The top .net development companies deliver dependable results because their teams combine technical abilities with their experience in specific industrial sectors. The best net development companies and Software Development Company partners provide complete development services which include project planning and coding work and software deployment and system upkeep services to help businesses succeed in their digital transformations.

Why Businesses Hire a .NET Development Company

The .net development company will deliver secure and scalable applications which enable businesses to achieve their growth targets. Organizations which use .net development services gain access to developers who can create and manage digital systems through their advanced design capabilities. A dependable .net development company delivers projects more quickly while it decreases technical challenges and operational expenses.

The majority of businesses select either an asp net development company or a custom .net development company to develop specialized applications which match their unique operational needs. The .net development companies possess documented abilities which enable them to handle every project with their advanced tools and industry-standard techniques.

The selection of an appropriate net development company together with a trustworthy Software Development Company enables organizations to obtain scalable system designs which boost their system efficiency and provide ongoing technical assistance. Businesses utilize .NET specialists to speed up digital changes which improve user experiences and help them stay competitive in the changing technology environment.

Key Services Offered by a .NET Development Company

The .net development company offers various services which assist businesses in creating applications that meet security requirements and can expand their operations while maintaining high performance standards. The .net development company provides professional .net development services to create customized web applications and enterprise software systems and cloud-based solutions which meet specific business requirements.

The asp net development company uses its experience to build applications which use data to boost operational efficiency and enhance user experience. Many organizations use custom .net development companies to create solutions which meet their specific operational needs and industry requirements.

.Net development companies provide API development services and system integration services and migration services and ongoing maintenance services to ensure clients maintain system stability throughout their operations. The selection of an appropriate net development company or dependable Software Development Company enables organizations to access contemporary technologies and agile development methods and ongoing assistance.

Factors to Consider When Hiring a .NET Development Company

The process of choosing a .net development company requires assessment of multiple critical factors which determine whether the project achieves its objectives. The first step requires evaluation of .net development services which includes both web applications and enterprise solutions and cloud integration services.

A dependable .net development company should possess strong skills to create applications which can scale and maintain security for specific business requirements. The technical skills and industry experience of an asp net development company can be assessed through their previous project work which shows their technical skills and industry knowledge.

The selection of a custom .net development company should focus on providers who create tailor-made solutions which fulfill your particular needs. Among various .net development companies, prioritize those with transparent communication, agile practices, and proven delivery timelines. The best net development company will also provide long-term maintenance and support.

Benefits of Hiring the Right .NET Development Partner

The selection of an appropriate .net development company provides businesses with major benefits when they need to create applications that can scale and deliver high performance. The .net development service provider will execute your project through his technical knowhow and contemporary technology and his knowledge of industry standards.

Your partnership with any .net development company or veteran asp net development company provides you access to developers who create secure and effective solutions which will remain relevant in the future.The custom .net development company creates unique applications which match your business requirements to boost productivity and enhance the user experience.

The correct partner among elite .net development companies delivers faster product launch times together with lower development risks through their established development methods.The selection of an optimal net development company together with a trusted Software Development Company enables businesses to establish long-lasting system expansion which enables smooth system connectivity and perpetual system maintenance services.

Common Mistakes to Avoid When Hiring

The .net development company selection process contains common hiring errors which result in negative effects on project outcomes. The first mistake occurs when organizations select a vendor who provides the lowest price instead of verifying the vendor's skills and their potential for future benefits. The .net development firm should have strong technical skills and proven experience to provide its clients professional .net development solutions.

The second mistake occurs when organizations fail to consider their needs for scalability and their requirements for upcoming expansions. The asp net development company and custom .net development company should create adaptable solutions which meet the changing requirements of their clients. The clients do not assess portfolios and client testimonials which should be used to select appropriate .net development companies for their projects.

The project suffers from a severe problem because the team disregards post-launch support which creates a need for maintenance to safeguard system performance and security. The selection of a .net development company or a Software Development Company enables clients to access continuous support services while improving their communication with reduced project risks.

Future Trends in .NET Development

The .NET development field is experiencing quick changes, which forces businesses to hire .net development companies for their technological needs. Current .net development services now adopt cloud-native architectures together with microservices and AI-powered applications to achieve better scalability and performance.

The .net development company or asp net development company that practices forward-thinking now works to combine .NET technologies with Azure and DevOps pipelines and serverless computing for their customers. The .net development company will develop customized data-based applications which meet particular business requirements in the upcoming years.

The leading .net development companies use containerization and automation technologies to achieve better deployment processes. The selection of either the top net development company or a trustworthy Software Development Company provides organizations with access to groundbreaking technologies which improve their security measures while enabling their digital development over time.

Conclusion

The selection of a Software Development Company needs to be done correctly because it directly affects the development of dependable applications that can grow and deliver high performance. A trusted .net development firm ensures access to skilled professionals who deliver tailored solutions aligned with business goals. Organizations that use expert .net development services will achieve better operational efficiency, increased performance capabilities, and decreased risks related to their future development processes. Organizations can achieve digital success through their partner evaluation and hiring process because it enables them to maintain secure applications that will stay relevant in future developments while competing with other businesses.

How a .NET Development Company Improves Application Security and Performance

Wed, 22 Apr 2026 04:31:07 +0000

The .NET development company delivers essential services to create secure high-performance applications which meet contemporary business requirements. Organizations now depend on professional .net development services to create operational applications which can withstand digital security threats and performance challenges because digital ecosystems have become more complex. The .NET development firm uses .NET framework features to build security systems and design optimal system architecture and deliver user-friendly experiences.

Companies use industry best practices plus advanced tools to protect sensitive data and boost application performance through every stage of their development process. Businesses need to work with experienced .NET development companies because their cybersecurity needs grow while users demand better experiences to help them stay competitive and protect their digital assets and maintain dependable systems which support their business goals.

Understanding the Role of a .NET Development Company

The .NET development company which you hire will develop applications that provide security and scalability and high performance through their work on your specific business requirements. The .NET development companies provide full .NET development services which cover all aspects from initial design to system deployment and ongoing support.

The .NET development company uses ASP.NET framework together with other frameworks to build secure web applications and desktop software and cloud solutions.The asp net development company which has many years of experience implements secure coding methods while they boost application efficiency and achieve smooth system connections.

The custom .net development company provides specialized development services which work better than the .NET development company services from top development companies.Organizations work with .net development companies and Software Development Companies to obtain access to developers who use advanced tools and established development practices.

Key Security Challenges in Application Development

How a .NET Development Company Enhances Application Security

The .net development company implements industry-standard security measures together with .NET framework security features to protect application security. Businesses receive .net development services which include secure coding standards that protect against SQL injection and cross-site scripting and protection from data breaches.

The professional .net development firm or asp net development company builds secure authentication and authorization systems which restrict access to sensitive information to validated users. The custom .net development company develops secure applications through its work on data encryption and secure API development and its execution of ongoing security checks.

The leading .net development companies utilize their advanced threat detection technology together with their security compliance capabilities to safeguard their systems. The best net development company or a trusted Software Development Company delivers continuous system monitoring and software updates while performing ongoing risk assessment activities.

Performance Challenges in Modern Applications

Modern applications face significant performance challenges because user expectations and data requirements continue to increase. A .net development company needs to solve three main problems which include scalability and latency and resource optimization to create smooth user experiences.

The .net development services need to implement effective system designs because high traffic volumes will cause system performance issues if they are not properly handled. Poor database queries together with unoptimized code create bottlenecks which decrease system responsiveness to user requests.

The best asp net development company together with custom .net development companies use caching and load balancing methods and asynchronous programming techniques to improve application performance. Many .net development companies also use cloud integration for their projects because it improves system scalability and system reliability.

How a .NET Development Company Optimizes Performance

The .net development company delivers high-performing applications through its combination of efficient coding practices and modern architecture design. The .net development teams use their expertise to build scalable solutions which employ microservices and caching technologies together with asynchronous programming methods to achieve faster response times and lower latency.

The .net development company delivers reliable services by optimizing database queries while reducing resource use and creating smooth cloud platform connections.The asp net development company uses its built-in performance functions which include just-in-time compilation and advanced memory management to boost system speed.

The custom .net development company creates solutions which align with specific business requirements to maintain peak performance during different operational periods. The top .net development companies implement monitoring tools which help them find system bottlenecks while they work to enhance overall operational efficiency.

Tools and Technologies Used by .NET Development Companies

The .NET development company requires modern tools and frameworks for building secure and high-performing applications. The top .NET development companies create scalable and efficient solutions through their use of Visual Studio and .NET SDK and ASP.NET Core. A reliable asp net development company also integrates cloud platforms like Microsoft Azure for hosting, monitoring, and auto-scaling applications.

Organizations use SQL Server and Entity Framework as their primary database management tools to achieve optimal data access and safeguard data security.The custom .NET development company uses DevOps tools such as Docker and Kubernetes and Azure DevOps for continuous integration and deployment to improve both performance and security.

Developers need testing frameworks which include NUnit and xUnit because those tools help them to maintain code quality standards. Security tools which include built-in .NET authentication libraries provide protection for applications against potential security vulnerabilities.

Benefits of Hiring a Professional .NET Development Company

Businesses building secure high-performing applications receive major benefits from hiring professional .NET development companies. A skilled .net development company ensures that applications are developed using industry best practices, which leads to security improvements and reduces the chances of security breaches.

A reliable .net development firm uses its advanced frameworks and tools to create secure coding standards and encryption methods and authentication systems that protect sensitive data from threats.The top asp net development company works to improve application performance through its development of efficient architecture and caching strategies and scalable cloud solutions.

The custom .net development company delivers specialized solutions which meet the specific operational requirements of businesses that select this service. Leading .net development companies provide ongoing maintenance services together with performance monitoring services to maintain stability throughout extended periods.

Conclusion

A trustworthy .net development company creates secure applications which perform optimally to meet current business requirements. The .net development company uses advanced tools and best practices together with continuous monitoring to provide effective security solutions which maintain system performance and scalability. Professional .net development services create better application performance which helps businesses achieve their digital goals through improved user experiences.

How a .NET Development Company Powers Modern Business Applications

Wed, 22 Apr 2026 03:55:02 +0000

The current software development company assists businesses by creating digital products that can scale and remain secure while delivering high performance. The .NET framework has become the top choice for enterprise application development because it provides developers with development options that they can rely on to create applications which run across different platforms.

A professional .net development company leverages these strengths to design and deliver powerful business applications that meet evolving market demands. Organizations use .net development services to create web and mobile and cloud solutions which match their unique operational requirements. Businesses use these services to create better workflows which result in higher efficiency and better customer experiences.

A trusted .net development firm focuses on combining modern architecture, secure coding practices, and advanced development tools to ensure robust application performance. .NET enables businesses to achieve their digital transformation goals because it provides them with innovative solutions which can scale up their operations and link their systems together.

Understanding a .NET Development Company

A .net development company is a specialized technology partner that designs, builds, and maintains scalable business applications using Microsoft’s .NET framework. The companies provide complete .net development services which include development of web applications and enterprise software and cloud-based systems and application programming interface integrations that businesses require.

The professional .net development firm creates digital solutions which are secure and high-performing and future-ready to help businesses grow and operate more efficiently.The experienced asp net development company creates strong backend systems together with interactive web applications, while the custom .net development company delivers specific solutions for different industry needs.

.Net development companies apply modern technologies to their work which includes cloud computing and microservices and DevOps to boost their operational capacity and business growth.The best net development company together with a trusted Software Development Company provides access to skilled developers who deliver optimal architectural solutions and dependable client assistance.

Role of .NET in Modern Application Development

.NET plays a vital role in contemporary application development because it enables developers to create business solutions that can grow in size while maintaining security and optimal system performance. The top .net development company uses the framework to build applications that handle complex business needs. Businesses can create web, desktop, and cloud-based solutions through advanced .net development services which deliver uninterrupted performance on all platforms.

The .NET framework enables trusted asp net development companies and custom .net development companies to build flexible applications which help their clients achieve their business objectives. .NET development companies use the framework's adaptable features to build systems which combine cloud computing and API and microservices technologies for better resource management and scaling capabilities.

The best net development company or experienced .net development firm uses .NET tools and libraries to achieve faster development times while enhancing security measures and improving system performance. The .NET framework enables professional software development companies to create applications which businesses can depend on for future digital requirements while maintaining system reliability and easy maintenance.

How a .NET Development Company Powers Applications

The .net development company provides crucial support to modern businesses by developing digital solutions which enable businesses to create applications that can grow secure and perform at high levels. Companies achieve operational efficiency through advanced .net development services which enable them to create web applications mobile applications and cloud-based solutions.

An asp net development company specializes in building strong system designs which enable organizations to meet their complex business demands while creating smooth customer experiences.The custom .net development company creates customized software solutions which help businesses achieve their particular objectives while maintaining flexibility and seamless third-party system connections.

The leading .net development companies use automation along with API development and cloud technologies to improve their applications' operational capabilities.The top net development company or experienced .net development firm ensures optimized performance, strong security measures, and continuous support throughout the development lifecycle.

Security Features in .NET Applications

The .NET framework provides modern applications with strong security features which make it the best choice for enterprise businesses. The .net development company uses advanced security systems to safeguard their applications against data breaches and cyberattacks. The .net development services enable businesses to access pre-installed authentication and authorization and secure session management frameworks.

The asp net development company and custom .net development company provide protection for sensitive information by implementing encryption measures which comply with established industry standards. The top .net development organizations use secure coding techniques together with ongoing vulnerability testing to achieve application security.

The best net development company or experienced .net development firm integrates multi-factor authentication, role-based access control, and compliance standards to enhance protection. The software development company which uses .NET technology develops business applications which provide security and scalability and resilience while protecting sensitive information and delivering an uninterrupted user experience.

Performance Optimization Strategies

The .net development company focuses on performance optimization to create business applications which deliver high-speed performance and scalability and dependable operation. Advanced .net development services enable developers to establish efficient coding methods which decrease memory usage and boost application performance.

Professional asp net development companies achieve continuous operation during peak usage periods through their use of asynchronous programming and caching systems and their implementation of database query optimization techniques. The trusted custom .net development company uses microservices and load balancing to improve workload distribution based on their architectural design work.

The leading .net development companies use performance monitoring tools to find performance issues which they use to enhance application performance through ongoing application tuning. The best net development company or experienced .net development firm ensures applications remain scalable and responsive as business needs grow. Software Development Companies which establish trust deliver deployment acceleration and system performance gains through their implementation of DevOps and cloud optimization methods.

Technologies Used by .NET Development Companies

The current technology stack of a .net development company enables the creation of secure and scalable applications which the company delivers through its advanced technology capabilities. The top .net development service providers use ASP.NET Core and MVC and .NET 8 frameworks to create high-performance web applications and enterprise solutions.

A trustworthy asp net development company implements cloud solutions through Microsoft Azure and AWS to deliver flexible infrastructure and scaling capacity and smooth operational transitions.The custom .net development company utilizes DevOps tools which include Azure DevOps and Jenkins and Docker to establish continuous integration and delivery processes that enhance their development productivity.

The modern databases which .net development companies use for their data management needs include SQL Server and PostgreSQL. The leading net development company or the skilled .net development firm uses API development and microservices architecture and front-end frameworks like Angular or React to deliver complete full-stack solutions.

Benefits of Hiring a .NET Development Company

Businesses gain flexible and protected digital solutions through .NET development company services which deliver both scalable and high-performance solutions for current business requirements. A professional .net development company delivers robust applications that improve efficiency and streamline operations through advanced architecture and clean coding practices.

Businesses achieve faster development cycles and reduced downtime and improved system reliability through expert .net development service usage.Trusted asp net development companies and custom .net development firms design solutions which help businesses achieve their specific objectives while providing them with adaptable systems which grow with their needs.

Leading .net development companies also provide strong security measures which protect applications from potential cyber threats while they comply with required security regulations.Organizations can establish connections with advanced .net development companies or experienced .net development firms which enable them to use contemporary technologies including cloud integration and APIs and automation tools.

Future of .NET in Business Applications

The .NET platform will drive business application development through ongoing technological advancements which businesses adopt through their cloud systems and through their use of intelligent automation technologies. A modern .net development company uses emerging AI and machine learning and microservices technologies to create enterprise solutions which can grow with business needs.

Modern .net development services enable organizations to develop secure, high-performance applications that adapt quickly to changing market demands. The custom .net development company together with the asp net development company delivers businesses flexible solutions which enhance their operational agility and productivity.

.NET development companies increasingly adopt DevOps together with cloud-native architectures because digital transformation accelerates their ability to deliver software at greater speed with improved system reliability. .net development firms or the best net development company deliver extended project value through their commitment to establishing security systems and automation processes and performance enhancement methods.

Conclusion

The .NET development company develops business applications which enable digital transformation through secure and scalable systems and high-performance applications. Advanced .net development services help businesses to operate more efficiently by enhancing their operational processes and creating better user experiences. The dependable .net development company provides two essential services which include building strong system designs and enabling smooth system connections while maintaining application performance for an extended period. Organizations that work with experienced Software Development Companies can maintain their market competitiveness while protecting their business applications through continuous security updates and performance enhancements.

Why Businesses Choose a .NET Development Company for Scalable Solutions

Fri, 17 Apr 2026 07:53:49 +0000

Businesses need strong and expandable applications to maintain their market position and handle increased user traffic in the rapidly changing digital world. The professional .net development company provides essential support to fulfill this requirement. Organizations can leverage .NET framework functions for their development of high-performance and secure solutions which meet their specific requirements. Enterprises depend on expert .net development services to achieve smooth application development and system integration while maintaining operational capacity across different platforms.

The .net development firm provides trusted technical skills and extensive industry knowledge together with strategic business guidance that helps organizations speed up their development processes without compromising product quality. .NET provides all necessary resources to businesses for growing their operations across enterprise software and cloud applications and contemporary web development platforms. The correct development experts should be chosen by businesses who want to succeed in their digital transformation and growth initiatives.

Understanding the .NET Framework

Microsoft developed the .NET framework as a powerful platform which allows developers to create applications that can scale secure systems while delivering high-performance results. The platform enables developers to create applications for web desktop mobile and cloud environments by supporting multiple programming languages which include C# programming language. Companies use .net development services from either .net development companies or custom .net development companies to use this framework properly.

The .net development services which professional .net development firms and asp net development companies provide enable businesses to create applications which integrate seamlessly with their existing systems while delivering flexible solutions and faster deployment times. The top net development company and experienced .net development companies help organizations create enterprise-grade solutions based on their expertise. The Software Development Company uses .NET to create reliable applications which can expand their capacity while securing performance and protection standards for multiple industries.

The Importance of Scalability in Modern Applications

The development of contemporary applications requires organizations to use scalability as an essential element which enables them to manage increasing user demands, data expansion, and changing market conditions without performance degradation. A reliable .net development company establishes efficient system scaling methods which enable their clients to achieve permanent system stability at reduced operational costs.

Business operations use .net development services to build flexible systems which enable vertical and horizontal growth.An established asp net development company together with a custom .net development company creates applications which handle higher workload demands to help businesses keep their competitive advantage. Most .net development companies concentrate on developing cloud integration solutions together with microservices to improve their systems' ability to scale.

The selection of either the top net development company or a reliable Software Development Company provides businesses with access to cutting-edge technical resources and specialized knowledge. The implementation of .net development services enables businesses to protect their applications from future changes while they maintain continuous delivery of superior user experiences.

Why Choose a .NET Development Company

The selection of a .NET development company enables businesses to receive dependable and expandable and high-performance applications which meet their specific requirements. A professional team offering .net development services brings deep expertise in building secure and flexible solutions using modern technologies.

When you engage with a .net development firm or an asp net development company, you gain access to developers who possess expertise in handling enterprise-level project demands.The custom .net development company develops specific applications which match your business objectives while providing smooth integration and future growth possibilities. The majority of .net development companies offer ongoing support services, which help organizations minimize their operational risks across extended time periods.

The top net development company enables businesses to boost their market entry speed without compromising their product quality or performance benchmarks.Business organizations pursuing sustainable development need to select Software Development Company as their partner because its .NET ecosystem helps them build cloud-ready solutions which maintain cost-effective operations.

Key Features of .NET for Scalable Solutions

.NET provides developers with a high-performance building platform which enables them to create applications that can seamlessly expand their capabilities and their operational efficiency. The Software Development Company can develop applications which operate smoothly on Windows and Linux and macOS because of their cross-platform system capabilities.

The built-in cloud integration capabilities Microsoft Azure provides businesses with a simple way to expand their resource capacity according to their current needs.The security framework of .net development services provides strong protection which safeguards data while helping organizations meet their compliance requirements.

The combination of microservices architecture with containerization technology enables a custom .net development company to build systems that can adjust their capacity to meet changing needs. The continuous updates of the system provide high performance which makes it the preferred option for both asp net development companies and .net development firms.

Benefits of Hiring a Professional .NET Development Company

.NET development companies provide businesses with essential support for developing secure and expandable applications through their professional development services. The .net development company provides dependable services through its technical expertise which enables delivery of custom solutions that meet client requirements.

Organizations that use .net development services can achieve faster development cycles without sacrificing their system performance or operational agility. Developers who use contemporary methods and tools work together with .net development partners and asp net development companies to deliver their expertise to clients.

The custom .net development company creates solutions which match the specific operational requirements of its clients to enhance their operational efficiency and user satisfaction. The leading .net development companies deliver continuous system maintenance together with system updates and system compatibility support for existing customer systems.

Use Cases of .NET in Scalable Business Applications

companies from all sectors use .NET framework. to develop systems which provide better performance while supporting future user growth. A professional .net development company helps organizations design enterprise-grade systems such as customer relationship management (CRM) platforms, enterprise resource planning (ERP) systems, and large-scale eCommerce applications.

A custom .net development company provides organizations with unique solutions which function according to their specific requirements while maintaining both performance and security standards.Many .net development companies also specialize in building cloud-based SaaS platforms that require seamless scalability and uptime. The asp net development company creates web applications that maintain fast performance during periods of high user traffic.

The top net development company or trusted .net development firm helps businesses integrate their systems with AI technologies, IoT devices, and data analytics solutions.The Software Development Company uses dot net development services to enable businesses to connect their systems with existing software while they expand their systems and maintain their operations.

Comparison with Other Development Technologies

The assessment of development stacks by businesses begins with a comparison between .NET and other programming languages which include Java, Node.js, and Python-based frameworks. A .NET Development Company stands out from its competitors because its enterprise support and security features and ability to handle large-scale applications function as its primary strengths.

.NET enables users to work with Microsoft tools more effectively, while Java development takes longer to complete. The system delivers better organizational support for enterprise-grade applications, which need complete system performance and Node.js compatibility.

Python frameworks specialize in artificial intelligence and data science work, while .NET provides better capabilities for creating dependable business software that operates in production environments.The .NET development company or .NET development firm delivers complete .NET development services for their clients which results in easier deployment and ongoing maintenance work.

How to Choose the Right .NET Development Company

The process of selecting an appropriate partner remains vital for the development of applications which need to grow and maintain their security. The .net development company must demonstrate its ability to deliver enterprise-level solutions through modern Microsoft technologies which it has already established as reliable expertise. The assessment should begin with an examination of their technical abilities which need to include ASP.NET and cloud integration and microservices architecture.

A reliable asp net development company needs to show its capability to create and manage applications which function at high traffic levels and require intricate systems to operate. The web sites of various .net development firms need evaluation to find out their experience in different fields and their previous successful projects. A reliable custom .net development company should provide customized services for each client rather than using standard solutions which apply to all customers.

The company needs to deliver complete .net development services which encompass the entire process from design to development and deployment and maintenance. The company needs to present their work through client testimonials and case studies while also showing their ability to handle communication with clients. The top net development company will deliver solutions which prioritize both security and scalability while providing ongoing support for extended periods.

Future of .NET in Scalable Application Development

The future of .NET will provide highly promising prospects for developing scalable applications because businesses require cloud-ready solutions with flexible operation and high-performance capabilities. A modern .NET development company helps organizations build enterprise-grade applications which enable their business growth through its essential development services.
The ongoing advancement of cloud computing and microservices technology and AI integration has created new .NET development services which allow businesses to build secure and efficient systems. All leading .NET development companies and every forward-thinking .NET development firm are adopting .NET 8+ to deliver cross-platform and containerized solutions.
The ASP.NET development company and custom .NET development company both provide businesses with custom solutions which fulfill their specific requirements. The best .NET development company stands out in the market because it provides innovative solutions which help them achieve business growth and operational flexibility and dependability.

Conclusion

The selection of a .NET development company enables organizations to create applications which can expand while maintaining safety and delivering optimal performance for their growth requirements. The .net development services provide organizations with contemporary technological solutions and cloud-based software and dependable operational assistance. The dedicated .net development company delivers both budget control and efficient project implementation while providing enduring advantages to clients. Experienced professionals enable companies to maintain market competitiveness while their digital needs evolve through the development of innovative solutions which can be scaled to handle upcoming business demands while ensuring security and operational effectiveness across different commercial environments.

How .NET Development Companies Modernize Legacy Systems

Thu, 16 Apr 2026 04:08:15 +0000

The outdated systems which many businesses use today create substantial difficulties because they prevent organizations from expanding their operations and achieving better performance results and developing new technologies. A modern .NET development company plays a vital role in transforming these outdated systems into efficient, cloud-ready solutions. The .NET development firm uses its advanced frameworks and tools to assist businesses with application migration and refactoring and optimization tasks while maintaining their essential business operations. Organizations need this transformation to achieve competitive advantage in their digital environment which keeps changing rapidly.

Through specialized .NET development services, companies can modernize legacy applications by adopting microservices architecture, integrating APIs, and moving workloads to cloud platforms like Microsoft Azure. The services maintain both enterprise system security and operational performance capabilities through dedicated systems which deliver ongoing protection and operational support. A skilled .NET development company not only upgrades technology but also aligns IT infrastructure with current business goals. Modernization provides enterprises with flexible operations and lower operational expenses and improved customer experiences which makes it a required business strategy.

Role of a .NET Development Company in Legacy Modernization

The .NET development company provides vital services which help organizations upgrade their outdated systems into contemporary scalable systems that operate with enhanced efficiency. Through expert .net development services organizations assess their legacy systems to find performance issues and create a complete plan for system modernization.

The custom .NET development company provides trusted services which enable organizations to modernize their aging monolithic systems through cloud-native and microservices re-architecting methods.The ASP.NET development company provides services which help clients move their existing web applications to the ASP.NET Core framework.

The .NET development companies and the trusted .NET development firm develop systems that use APIs for automation and data migration which allows business operations to continue without interruptions.The best net development company partnership enables enterprises to decrease their technical debt while achieving better system performance and cost savings that last for years.

Challenges of Legacy System Modernization

Every .NET development company needs to handle the difficult task of modernizing legacy systems according to their established operational procedures. The first main obstacle of the project involves managing outdated systems which require advanced .NET development services to achieve successful modernization. Organizations depend on custom .NET development companies or ASP.NET development companies to solve their compatibility challenges while their operations continue without interruption.

The second major obstacle businesses face during data migration occurs when they need to protect sensitive data through secure transfer methods that prevent any data loss or corruption. A .NET development firm needs to fix both performance bottlenecks and security vulnerabilities which exist in legacy systems according to the requirements of their work for top .NET development companies.

The process of modernization becomes more difficult because documentation is insufficient and outdated technologies create a need for extended time periods. The selection between an excellent development company and a reliable Software Development Company establishes which development company will provide maximum risk reduction. Successful legacy system transformation requires both detailed planning and professional execution according to the established requirements.

Approaches Used by .NET Development Companies

A modern .NET development company plays a vital role in transforming outdated systems through structured modernization strategies. Replatforming constitutes one of the primary methods which custom .NET development companies use to move legacy applications into modern frameworks through .NET Core and .NET 8 migrations while maintaining their original functions.

The best net development company uses refactoring to improve existing code which results in better performance and scalability and security enhancements.Many .NET development companies also use rearchitecting techniques which transform monolithic systems into microservices through .net development services to achieve better system flexibility. The process of API integration creates a crucial method which establishes direct communication links between outdated systems and contemporary systems.

The experienced ASP.NET development company improves its scalability through Microsoft Azure cloud platforms which also helps the company decrease its expenses for infrastructure.A leading .NET development firm or Software Development Company uses automation together with DevOps and CI/CD pipelines to achieve continuous modernization processes which create minimal disruptions for their business operations.

Tools and Technologies in .NET Modernization

The .NET development company utilizes its advanced technology stack to execute system modernization through advanced tools and expert knowledge. The .net development companies use ASP.NET Core and .NET 8+ and C# to transform existing applications into better performing systems which can handle increased user demand.

Microsoft Azure public cloud platform provides essential services which support organizations to migrate systems and create container-based applications and execute hybrid deployment methods.The custom .NET development company uses DevOps tools which include Azure DevOps and Jenkins and GitHub Actions to create CI/CD pipelines which enable rapid and secure software delivery.

The best net development company uses microservices architecture and Docker containers to create modular system components which replace traditional monolithic software design.The trusted Software Development Company uses API management tools and security frameworks and monitoring solutions to maintain system stability in the .NET development services they provide.

Benefits of Modernizing with a .NET Development Company

Businesses that want to maintain digital competitiveness should use .NET development services to modernize their existing systems. The trusted custom .NET development company delivers advanced .NET development services to help organizations transform their outdated infrastructure into secure and high-performing scalable solutions.

The performance of a business system will be enhanced while downtime will be reduced through work with experienced .NET development companies.The ASP.NET development company provides customers with seamless framework migration services that help them move to ASP.NET Core which improves their ability to connect with cloud services and work across different platforms.

The top .NET development firm helps businesses decrease their operational expenses by eliminating technical debt and making their systems easier to manage. The best net development company uses automation and DevOps and microservices architecture to drive innovation at an accelerated pace. The Software Development Company specializing in .NET supports enterprises through effective legacy system modernization.

Choosing the Right .NET Development Company

The process of selecting a .NET development company requires businesses to choose the most appropriate company to achieve their goal of updating outdated systems. The evaluation process for custom .NET development company selection should begin with an assessment of their expertise and technical skills and their experience in specific industries.

The top .NET development company will showcase its legacy modernization work through multiple successful projects which demonstrate its expertise with Microsoft technologies including .NET Core and Azure. A Software Development Company must be selected according to its ability to adopt contemporary development methods which include DevOps and microservices architecture and agile development practice.

A trusted partner delivers transformation results through which organizations achieve better performance outcomes and enhanced security features and greater system capacity. The .NET development company which best fits the business needs of the organization enables companies to perform system upgrades through digital solutions which achieve both modern requirements and future business expansion goals.

Future of Legacy System Modernization

The advanced development services of .NET development services allow organizations to modernize their outdated legacy systems through cloud-enabled agile infrastructure solutions. A modern .NET development company plays a crucial role in helping businesses migrate from monolithic architectures to scalable microservices and API-driven ecosystems.

The custom .NET development company provides businesses with tailored modernization strategies which meet their specific business goals as their demand for services increases. All .NET development firms and .NET development companies are now using AI and automation together with cloud-first solutions to modernize their existing systems because Microsoft technologies keep developing at a fast pace.

The professional ASP.NET development company enables enterprises to enhance their system performance while maintaining better security and operational capacity through its development services. The leading Software Development Company and the best net development company specialize in three main areas which include application reengineering and modern DevOps practice integration together with seamless migration.

Conclusion

The digital environment of contemporary business demands that organizations update their outdated systems to maintain their market position. The .NET development company provides trustworthy services which help organizations update their old systems to create secure and advanced scalable performance systems. Advanced .NET development services enable businesses to upgrade their systems through smooth transitions to modern cloud and microservices architectures. The .NET development firm uses its expert knowledge to move projects forward while decreasing potential problems and increasing operational efficiency. The partnership with a skilled provider creates a path for continuous business growth and enhances system performance and fosters ongoing innovation throughout enterprise applications.

# The Rule Pattern in C#, and Why It Works So Well with the Result Pattern

Tue, 07 Apr 2026 10:01:22 +0000

The Rule Pattern in C#, and Why It Works So Well with the Result Pattern

Business rules rarely stay in one place.

A small validation starts in a command handler. Another check appears in a service. A third gets added somewhere in the domain. A few weeks later, the real business policy is scattered across the application, and nobody can see it clearly anymore.

That is exactly where the Rule pattern becomes useful.

At its core, the idea is simple. Instead of expressing business decisions as anonymous conditionals spread throughout the system, you give each rule a name and wrap it in its own object. Martin Fowler describes this style through the Specification pattern, where the statement of what satisfies a candidate is separated from the candidate itself, and those specifications can be combined into richer logic. (martinfowler.com)

In practical C# applications, especially the ones using CQRS or domain-driven design, that gives you something powerful: business rules that are explicit, reusable, and easy to reason about. (martinfowler.com)

What the Rule pattern really solves

The biggest problem is not that business checks exist. The problem is that they often exist in the wrong shape.

When rules are buried inside handlers, services, or controller actions, they are hard to spot, hard to test in isolation, and very easy to duplicate. The code still works, but the business language disappears.

The Rule pattern fixes that by turning each business condition into a named concept. Instead of asking developers to interpret a chain of low-level checks, the code starts speaking in terms the business would actually recognize. That is very much in line with DDD’s emphasis on modeling around the real language of the domain. (Microsoft Learn)

In other words, the pattern is not just about validation. It is about clarity.

Why it is often called the Specification pattern

If the shape feels familiar, that is because it usually is. What many teams call a Rule pattern is very close to what Fowler documented as Specification. The core idea is to represent business criteria as composable objects rather than raw conditionals, and then combine them with logical operations like AND, OR, and NOT. (martinfowler.com)

That is why this pattern tends to feel so natural in real systems. Business rules are rarely isolated. More often, they are layered:

A customer must be verified.
An order must reach a minimum amount.
A credit limit must not be exceeded.

On their own, each rule is simple. The real value appears when they can be combined into a meaningful policy.

Why this pattern becomes more valuable as the system grows

At first, a few inline checks seem harmless. But as the application grows, the cost of hidden business logic grows with it.

Rules get copied into multiple workflows.
One endpoint enforces them, another forgets.
A handler applies three checks, a background job applies only two.
Tests start focusing on branches instead of policies.

When rules become standalone concepts, those problems start to shrink. You can test a rule directly. You can reuse it in multiple flows. You can combine it with other rules. Most importantly, you can read the application flow and understand what it is trying to protect.

That is one of the reasons this pattern fits so well in systems that care about maintainability.

Where the Result pattern fits

The Rule pattern answers one question:

Is this action allowed according to the business?

The Result pattern answers another:

What happened when we tried to perform it?

That separation is the reason the two patterns fit together so well.

The rule evaluates business truth.
The result communicates application outcome.

Vladimir Khorikov’s writing on Result-based error handling makes this distinction especially useful for expected failures. Instead of throwing exceptions for normal business rejections, you can return an explicit failure outcome and keep the flow predictable. (Enterprise Craftsmanship)

That gives you a very clean mental model:

The domain decides.
The application reports.

Why this pairing feels so clean in practice

A good rule object should not care about HTTP, API responses, logging, UI wording, or transport concerns. Its responsibility is much smaller. It answers whether a business condition holds.

The application layer then takes that answer and decides what to do next. If the rule fails, the application can return a failure result. If it passes, the use case continues.

This separation lines up well with Microsoft’s DDD guidance, which treats validations as invariants and emphasizes that aggregates are responsible for enforcing consistency across state changes. (Microsoft Learn)

That is why the combination works so well. The rule keeps business logic clean. The result keeps flow control clean.

A simple order example, without the code

Imagine an order placement use case with three policies:

The order must meet a minimum amount.
The customer must be verified.
The order must stay within the customer’s credit limit.

Without a rule-based approach, those checks often end up inline inside the command handler. That works, but the handler slowly becomes the place where business policy lives.

With a rule-based approach, those policies become named rules. The handler simply coordinates the workflow: load data, build the order, evaluate the rule set, return a success or failure result, and persist when everything is valid.

That is a much healthier separation of concerns.

The handler stops being the place where business logic is invented, and becomes the place where business logic is orchestrated.

The biggest benefit is not flexibility, it is readability

People often talk about this pattern in terms of reuse or composability, and those are real benefits.

But the biggest benefit is readability.

When rules are named well, the code starts reading like a business conversation instead of a technical negotiation. That matters more than people think. Clear code reduces mistakes, speeds up maintenance, and makes onboarding easier for everyone who touches the system later.

A long chain of conditionals tells you how the system behaves.

A well-named rule tells you why.

One important design note

There is one trap worth mentioning.

Just because a rule is expressed cleanly does not automatically mean it belongs in the application layer.

Some rules are just use-case checks. Those can live comfortably near the workflow.

But some rules are true invariants of the domain. Those should usually be protected by the aggregate itself. Microsoft’s guidance is very clear on this point: aggregates are responsible for enforcing invariants across state changes. (Microsoft Learn)

So the right question is not only, “Can I model this as a rule?”

The better question is, “Who is responsible for protecting this rule?”

If the answer is “the domain itself,” then the aggregate should not rely on the handler to remember it.

Where this pattern can go wrong

Like most good patterns, this one becomes dangerous when overused.

Not every if statement needs to become a rule object.
Not every workflow needs an entire rules engine.
Not every tiny validation deserves its own abstraction.

If the business logic is trivial and local, introducing rule classes may create more ceremony than value.

The pattern shines when the rules are meaningful, reusable, and important enough to deserve a name. If the condition is just a one-off technical check, a plain conditional may still be the better choice.

The goal is not abstraction for its own sake. The goal is to make business intent easier to see.

Why the Result pattern keeps the design honest

The Result pattern adds a second layer of clarity.

A failure is no longer hidden behind a thrown exception for something the system fully expected. Instead, the caller gets an explicit outcome. That makes business rejections feel normal rather than exceptional, which is often the right model for application workflows. (Enterprise Craftsmanship)

When paired with rules, the flow becomes very natural:

Evaluate the business policy.
If it fails, return a failure result.
If it passes, continue the operation.

That is simple, predictable, and easy to test.

Final thought

The Rule pattern is one of those ideas that looks modest at first, but pays off more and more as the codebase grows.

It helps you name business policies.
It helps you reuse them.
It helps you combine them.
And when paired with the Result pattern, it gives your application a very clean way to both enforce rules and communicate outcomes. (martinfowler.com)

If your handlers are starting to fill up with business conditionals, this pattern is often a strong sign that the code wants a better language.

And that, more than anything else, is what good domain design is really about.

Source code :

https://github.com/stevsharp/RulePatternApplication

References

Martin Fowler, Specifications. (martinfowler.com)

Microsoft Learn, Designing validations in the domain model layer. (Microsoft Learn)

Microsoft Learn, Designing a DDD-oriented microservice. (Microsoft Learn)

Vladimir Khorikov, Error handling: Exception or Result? (Enterprise Craftsmanship)

Vladimir Khorikov, Advanced error handling techniques. (Enterprise Craftsmanship)

ASP.NET Core Custom Logger — Save Logs to Database (SQL)

Fri, 30 Jan 2026 09:30:43 +0000

ASP.NET Core already gives you solid logging out of the box, and if you want richer sinks and structured logs, Serilog is a common choice.

But sometimes you cannot use a ready made sink, because the company already has a legacy logging table with a fixed schema. In that case, you build a custom database logger that writes into that table.

This tutorial includes:

Database table
Logger options
Custom logger
Logger provider
Background queue (Channel)
Dapper SQL insert
Registration in Program.cs
Usage example

1️⃣ Create the SQL table

CREATE TABLE dbo.AppLogs
(
    LogId     BIGINT IDENTITY PRIMARY KEY,
    Ts        DATETIME2(3) NOT NULL,
    Level     NVARCHAR(20) NOT NULL,
    Category  NVARCHAR(200) NOT NULL,
    TraceId   NVARCHAR(64) NULL,
    Message   NVARCHAR(MAX) NOT NULL,
    Exception NVARCHAR(MAX) NULL,
    Scopes    NVARCHAR(MAX) NULL
);

CREATE INDEX IX_AppLogs_Ts    ON dbo.AppLogs(Ts);
CREATE INDEX IX_AppLogs_Level ON dbo.AppLogs(Level);

2️⃣ Add NuGet packages

dotnet add package Dapper
dotnet add package Microsoft.Data.SqlClient

3️⃣ Logger options

public sealed class DbLogOptions
{
    public string ConnectionString { get; set; } = string.Empty;
    public LogLevel MinLevel { get; set; } = LogLevel.Information;

    // Max number of log entries waiting in memory
    public int MaxQueue { get; set; } = 5000;
}

4️⃣ Log entry model

public sealed class DbLogEntry
{
    public DateTime Ts { get; set; }
    public string Level { get; set; } = "";
    public string Category { get; set; } = "";
    public string? TraceId { get; set; }
    public string Message { get; set; } = "";
    public string? Exception { get; set; }
    public string? Scopes { get; set; }
}

5️⃣ Custom database logger

using System.Diagnostics;
using System.Text.Json;
using System.Threading.Channels;
using Microsoft.Extensions.Logging;

public sealed class DbLogger : ILogger
{
    private readonly string _category;
    private readonly DbLogOptions _options;
    private readonly Channel<DbLogEntry> _channel;
    private readonly IExternalScopeProvider? _scopeProvider;

    public DbLogger(
        string category,
        DbLogOptions options,
        Channel<DbLogEntry> channel,
        IExternalScopeProvider? scopeProvider)
    {
        _category = category;
        _options = options;
        _channel = channel;
        _scopeProvider = scopeProvider;
    }

    public IDisposable BeginScope<TState>(TState state) =>
        _scopeProvider?.Push(state) ?? NullScope.Instance;

    public bool IsEnabled(LogLevel logLevel) => logLevel >= _options.MinLevel;

    public void Log<TState>(
        LogLevel logLevel,
        EventId eventId,
        TState state,
        Exception? exception,
        Func<TState, Exception?, string> formatter)
    {
        if (!IsEnabled(logLevel)) return;
        if (formatter is null) return;

        var traceId = Activity.Current?.TraceId.ToString();

        string? scopesJson = null;
        if (_scopeProvider is not null)
        {
            var scopes = new List<object?>();
            _scopeProvider.ForEachScope((s, list) => list.Add(s), scopes);

            if (scopes.Count > 0)
                scopesJson = JsonSerializer.Serialize(scopes);
        }

        var entry = new DbLogEntry
        {
            Ts = DateTime.UtcNow,
            Level = logLevel.ToString(),
            Category = _category,
            TraceId = traceId,
            Message = formatter(state, exception),
            Exception = exception?.ToString(),
            Scopes = scopesJson
        };

        // If queue is full, this returns false and the log is dropped
        _ = _channel.Writer.TryWrite(entry);
    }

    private sealed class NullScope : IDisposable
    {
        public static readonly NullScope Instance = new();
        public void Dispose() { }
    }
}

6️⃣ Logger provider (writes to SQL using Dapper)

This provider uses a bounded channel and a single background reader so request threads never block on SQL.

using System.Threading.Channels;
using Dapper;
using Microsoft.Data.SqlClient;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

public sealed class DbLoggerProvider : ILoggerProvider, ISupportExternalScope
{
    private readonly DbLogOptions _options;
    private readonly Channel<DbLogEntry> _channel;
    private readonly CancellationTokenSource _cts = new();
    private IExternalScopeProvider? _scopeProvider;

    public DbLoggerProvider(IOptions<DbLogOptions> options)
    {
        _options = options.Value;

        var channelOptions = new BoundedChannelOptions(_options.MaxQueue)
        {
            SingleReader = true,
            SingleWriter = false,
            FullMode = BoundedChannelFullMode.DropOldest
        };

        _channel = Channel.CreateBounded<DbLogEntry>(channelOptions);

        _ = Task.Run(ProcessQueueAsync);
    }

    public ILogger CreateLogger(string categoryName) =>
        new DbLogger(categoryName, _options, _channel, _scopeProvider);

    public void SetScopeProvider(IExternalScopeProvider scopeProvider) =>
        _scopeProvider = scopeProvider;

    public void Dispose()
    {
        _cts.Cancel();
        _channel.Writer.TryComplete();
        _cts.Dispose();
    }

    private async Task ProcessQueueAsync()
    {
        const string sql = @"
INSERT INTO dbo.AppLogs (Ts, Level, Category, TraceId, Message, Exception, Scopes)
VALUES (@Ts, @Level, @Category, @TraceId, @Message, @Exception, @Scopes);";

        try
        {
            while (await _channel.Reader.WaitToReadAsync(_cts.Token))
            {
                while (_channel.Reader.TryRead(out var entry))
                {
                    await using var conn = new SqlConnection(_options.ConnectionString);
                    await conn.ExecuteAsync(sql, entry);
                }
            }
        }
        catch (OperationCanceledException)
        {
            // graceful shutdown
        }
    }
}

7️⃣ Add registration extension

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

public static class DbLoggerExtensions
{
    public static ILoggingBuilder AddDbLogger(
        this ILoggingBuilder builder,
        Action<DbLogOptions> configure)
    {
        builder.Services.Configure(configure);
        builder.Services.AddSingleton<ILoggerProvider, DbLoggerProvider>();
        return builder;
    }
}

8️⃣ Register in Program.cs

var builder = WebApplication.CreateBuilder(args);

builder.Logging.ClearProviders();
builder.Logging.AddConsole();

builder.Logging.AddDbLogger(options =>
{
    options.ConnectionString = builder.Configuration.GetConnectionString("DefaultConnection")!;
    options.MinLevel = LogLevel.Information;
    options.MaxQueue = 5000;
});

var app = builder.Build();

app.MapGet("/test", (ILogger<Program> logger) =>
{
    logger.LogInformation("Hello from DB Logger");
    logger.LogError(new Exception("Test"), "Something failed");
    return Results.Ok("OK");
});

app.Run();

Why we used Channels in the DB logger

Your logger needs to accept logs from many producers (web requests, background jobs, services) and write them to the DB via one efficient writer without blocking request threads or losing control when traffic spikes. Channels are a great fit:

Non blocking producers
Backpressure with bounded capacity
Single reader, many writers
Async, allocation friendly
Graceful shutdown

Source code:
https://github.com/stevsharp/DbLoggerSample

SQL Server and Azure SQL Updates with EF Core 10

Tue, 30 Dec 2025 21:06:54 +0000

EF Core 10 was released in November 2025 together with .NET 10 and is an LTS release supported until 2028. This version mainly focuses on better alignment with new SQL Server capabilities rather than introducing radically new concepts.

Below are a few changes that are worth noting from a practical point of view.

Vector data type support

EF Core 10 adds direct support for the vector data type introduced in SQL Server 2025 and Azure SQL. This makes it possible to store embeddings directly in the database without additional workarounds.

A simple entity example looks like this:

public class Blog
{
    public int Id { get; set; }

    [Column(TypeName = "vector(1536)")]
    public SqlVector<float> Embedding { get; set; }
}

Once the embedding is generated on the application side, it can be saved using the standard EF workflow:

context.Blogs.Add(new Blog
{
    Embedding = new SqlVector<float>(embedding)
});

await context.SaveChangesAsync();

Similarity queries can also be written directly in LINQ using EF.Functions.VectorDistance:

var blogs = await context.Blogs
    .OrderBy(b => EF.Functions.VectorDistance("cosine", b.Embedding, queryVector))
    .Take(3)
    .ToListAsync();

This is useful in scenarios such as semantic search or basic recommendation logic, without needing custom SQL or external query layers.

Native JSON data type mapping

With SQL Server 2025, JSON can now be stored using a dedicated json data type. EF Core 10 supports this natively and uses it automatically when the compatibility level allows it.

For example:

public class Blog
{
    public int Id { get; set; }
    public string[] Tags { get; set; }
    public BlogDetails Details { get; set; }
}

public class BlogDetails
{
    public int Viewers { get; set; }
}

Model configuration:

modelBuilder.Entity<Blog>()
    .ComplexProperty(b => b.Details, b => b.ToJson());

With this setup, both Tags and Details are created as json columns in the database.

Querying remains straightforward:

var blogs = await context.Blogs
    .Where(b => b.Details.Viewers > 3)
    .ToListAsync();

EF Core translates this into SQL using the appropriate JSON functions. For domains that already rely on JSON-like structures, this results in cleaner models and fewer mapping concerns.

Naming default constraints

EF Core 10 allows explicitly naming default constraints instead of relying on database-generated names. This can help reduce unnecessary changes in migrations and make schema updates easier to track.

Example:

modelBuilder.Entity<Post>()
    .Property(p => p.CreatedDate)
    .HasDefaultValueSql("GETDATE()", "DF_Post_CreatedDate");

It’s also possible to enable automatic naming across the model:

modelBuilder.UseNamedDefaultConstraints();

This change is mostly about maintainability, especially in projects with long migration histories.

Closing thoughts

EF Core 10 feels like a refinement release rather than a disruptive one. The added support for vector and JSON data types mainly improves how EF integrates with newer SQL Server features, while smaller changes like constraint naming help with long-term maintenance.

️ From Spaghetti to Scalable: Refactoring a Legacy .NET App Architecture

Sat, 22 Nov 2025 20:34:12 +0000

Every developer eventually inherits a legacy .NET project the kind where every method talks to everything, and a single change breaks three other features.

We had one of those too. And instead of rewriting from scratch, we decided to refactor and evolve it step by step. Here’s what made the difference

Started with understanding, not rewriting.
We mapped dependencies and identified the real pain points before touching a single line of code.

Introduced layers gradually.
Added separation between API, business logic, and data layers — even if it wasn’t “perfect” at first.

Applied Dependency Injection.
Breaking hard-coded dependencies gave us flexibility and made testing possible for the first time.

Moved toward Clean Architecture.
Organized the solution around use cases and domain logic, not around technical layers.

Incremental refactoring > big bang rewrites.
We refactored feature by feature while keeping the app running — zero downtime.

Added automated tests along the way.
Unit tests became our safety net for each refactored module.

Introduced modern tools gradually.
Switched to EF Core, MediatR, and background jobs via Hangfire — one at a time.

After months of iteration, we transformed a fragile legacy system into a modular, testable, and scalable architecture — without losing business continuity.

Have you ever refactored a legacy .NET project? What approach worked best for you?

dotnet #softwarearchitecture #refactoring #cleanarchitecture #csharp #softwareengineering #backend #devleadership #legacycode

Tutorial: Building a .NET 9 Console App with Hangfire and Channels

Thu, 20 Nov 2025 07:56:42 +0000

Tutorial: Building a .NET 9 Console App with Hangfire and Channels

Overview

In this tutorial, you will build a .NET 8 console application that:

Polls data from an API, or simulates it
Uses System.Threading.Channels for producer consumer messaging
Runs background tasks using Hosted Services
Enqueues jobs in Hangfire using in memory storage

Why Use System.Threading.Channels

Traditional producer consumer patterns often rely on BlockingCollection or custom queues, which can introduce:

Thread contention
Blocking calls
Complex synchronization

System.Threading.Channels provides:

Asynchronous, non blocking communication between producers and consumers
Built in backpressure when using bounded channels
High performance with low allocation

In this app:

DataPollingService is the producer, it writes work items into the channel
ChannelConsumerService is the consumer, it reads items and enqueues Hangfire jobs

Why Hosted Services

Hosted services, BackgroundService, integrate with the .NET Generic Host. You get:

Graceful lifecycle management, start and stop
Dependency injection
Logging and configuration
Non blocking background loops

This app uses two hosted services:

DataPollingService simulates fetching data and writes work items to the channel
ChannelConsumerService reads from the channel and enqueues Hangfire jobs

What is `BackgroundService`

BackgroundService is a base class that implements IHostedService and gives you a long running ExecuteAsync loop. It plugs into the Generic Host, so you get DI, logging, and coordinated shutdown.

Use cases

Poll APIs or message brokers
Drain a queue or channel
Run internal maintenance tasks

Key points

Use ExecuteAsync(CancellationToken) as your main loop
Respect the cancellation token for fast shutdown
Prefer PeriodicTimer over Task.Delay in recurring loops

What is Hangfire

Hangfire is a background job processor for .NET. You enqueue a method call, Hangfire persists and executes it with workers. It supports fire and forget, delayed, recurring, continuations, and batches.

Why it helps here

The consumer stays lightweight, it only enqueues work
Processing is retried and observable with a dashboard
You can swap storage later for durability

Common job types

Fire and forget, BackgroundJob.Enqueue(() => DoWork())
Delayed, BackgroundJob.Schedule(() => DoWork(), TimeSpan.FromMinutes(5))
Recurring, RecurringJob.AddOrUpdate("nightly", () => DoWork(), "0 2 * * *")

Notes, in memory storage is fine for demos, not for production. Jobs should be idempotent.

What is `System.Threading.Channels`

Channels are high performance, async friendly, in process queues. You get a ChannelWriter<T> for producers and a ChannelReader<T> for consumers. Channels work with async and IAsyncEnumerable<T>, and avoid blocking threads.

Why they shine

Async reads and writes
Bounded channels provide backpressure
Options like SingleReader and SingleWriter reduce overhead when true

Fast read loop

while (await reader.WaitToReadAsync(ct))
    while (reader.TryRead(out var item))
        await HandleAsync(item, ct);

Steps to Build

1. Create the Project

dotnet new console -n CustomerSyncConsole
cd CustomerSyncConsole

2. Add NuGet Packages

dotnet add package Hangfire
dotnet add package Hangfire.MemoryStorage
dotnet add package Microsoft.Extensions.Hosting
dotnet add package Microsoft.Extensions.Logging.Console

3. Implement the Code

Below is a complete Program.cs with comments. It uses an unbounded channel for simplicity. See the optional bounded channel section that follows if you want backpressure.

using System.Threading.Channels;
using Hangfire;
using Hangfire.MemoryStorage;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace CustomerSyncConsole;

public sealed record CustomerWorkItem(int CustomerId, string PayloadId, DateTimeOffset ReceivedAt, string RawJson);

public interface ICustomerJobs
{
    Task ProcessCustomer(int customerId, string payloadId, CancellationToken ct = default);
}

public sealed class CustomerJobs(ILogger<CustomerJobs> logger) : ICustomerJobs
{
    private readonly ILogger<CustomerJobs> _logger = logger;

    public async Task ProcessCustomer(int customerId, string payloadId, CancellationToken ct = default)
    {
        _logger.LogInformation("Hangfire job started for Customer {CustomerId}, Payload {PayloadId}", customerId, payloadId);
        await Task.Delay(TimeSpan.FromSeconds(2), ct);
        _logger.LogInformation("Hangfire job completed for Customer {CustomerId}, Payload {PayloadId}", customerId, payloadId);
    }
}

public interface IStorage
{
    Task SaveAsync(string payloadId, string rawJson, CancellationToken ct);
}

public sealed class InMemoryStorage(ILogger<InMemoryStorage> logger) : IStorage
{
    private readonly ILogger<InMemoryStorage> _logger = logger;
    private readonly Dictionary<string, string> _store = new();

    public Task SaveAsync(string payloadId, string rawJson, CancellationToken ct)
    {
        _store[payloadId] = rawJson;
        _logger.LogInformation("Saved payload {PayloadId} in-memory (size={Size}).", payloadId, _store.Count);
        return Task.CompletedTask;
    }
}

public sealed class DataPollingService(
    ILogger<DataPollingService> logger,
    Channel<CustomerWorkItem> channel,
    IConfiguration config,
    IStorage storage) : BackgroundService
{
    private readonly ILogger<DataPollingService> _logger = logger;
    private readonly ChannelWriter<CustomerWorkItem> _writer = channel.Writer;
    private readonly IConfiguration _config = config;
    private readonly IStorage _storage = storage;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var intervalSeconds = _config.GetValue("Polling:IntervalSeconds", 10);
        var timer = new PeriodicTimer(TimeSpan.FromSeconds(intervalSeconds));

        _logger.LogInformation("Polling started. Interval={Interval}s", intervalSeconds);

        try
        {
            while (await timer.WaitForNextTickAsync(stoppingToken))
            {
                var simulated = new[]
                {
                    new IncomingDto { CustomerId = 1, PayloadId = Guid.NewGuid().ToString("N") },
                    new IncomingDto { CustomerId = 2, PayloadId = Guid.NewGuid().ToString("N") },
                };

                foreach (var dto in simulated)
                {
                    var raw = System.Text.Json.JsonSerializer.Serialize(dto);
                    await _storage.SaveAsync(dto.PayloadId, raw, stoppingToken);

                    var item = new CustomerWorkItem(dto.CustomerId, dto.PayloadId, DateTimeOffset.UtcNow, raw);
                    await _writer.WriteAsync(item, stoppingToken);
                    _logger.LogInformation("Queued work item for Customer {CustomerId}, Payload {PayloadId}", dto.CustomerId, dto.PayloadId);
                }
            }
        }
        finally
        {
            _writer.TryComplete();
        }
    }

    private sealed class IncomingDto
    {
        public int CustomerId { get; set; }
        public string PayloadId { get; set; } = Guid.NewGuid().ToString("N");
    }
}

public sealed class ChannelConsumerService(
    Channel<CustomerWorkItem> channel,
    IBackgroundJobClient backgroundJobClient,
    ILogger<ChannelConsumerService> logger) : BackgroundService
{
    private readonly ChannelReader<CustomerWorkItem> _reader = channel.Reader;
    private readonly IBackgroundJobClient _backgroundJobClient = backgroundJobClient;
    private readonly ILogger<ChannelConsumerService> _logger = logger;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Channel consumer started.");
        await foreach (var item in _reader.ReadAllAsync(stoppingToken))
        {
            if (item.CustomerId == 1)
            {
                var jobId = _backgroundJobClient.Enqueue<ICustomerJobs>(job => job.ProcessCustomer(item.CustomerId, item.PayloadId, CancellationToken.None));
                _logger.LogInformation("Enqueued Hangfire job {JobId} for Customer {CustomerId}, Payload {PayloadId}", jobId, item.CustomerId, item.PayloadId);
            }
        }
        _logger.LogInformation("Channel consumer stopping.");
    }
}

public static class Program
{
    public static async Task Main(string[] args)
    {
        using var host = Host.CreateDefaultBuilder(args)
            .ConfigureAppConfiguration(cfg =>
            {
                cfg.AddInMemoryCollection(new Dictionary<string, string?>
                {
                    ["Polling:IntervalSeconds"] = "10"
                });
            })
            .ConfigureLogging(logging =>
            {
                logging.ClearProviders();
                logging.AddSimpleConsole(o =>
                {
                    o.TimestampFormat = "HH:mm:ss ";
                    o.SingleLine = true;
                });
                logging.SetMinimumLevel(LogLevel.Information);
            })
            .ConfigureServices((ctx, services) =>
            {
                // Unbounded for simplicity in this tutorial
                services.AddSingleton(Channel.CreateUnbounded<CustomerWorkItem>());

                // Hangfire in memory
                services.AddHangfire(config => config.UseMemoryStorage());
                services.AddHangfireServer();

                services.AddSingleton<ICustomerJobs, CustomerJobs>();
                services.AddSingleton<IStorage, InMemoryStorage>();
                services.AddHostedService<DataPollingService>();
                services.AddHostedService<ChannelConsumerService>();
            })
            .Build();

        await host.RunAsync();
    }
}

Optional, switch to a bounded channel

For services that can receive spikes, prefer bounded channels to get backpressure.

services.AddSingleton(_ =>
{
    var opts = new BoundedChannelOptions(capacity: 512)
    {
        FullMode = BoundedChannelFullMode.Wait,
        SingleReader = true,   // one consumer service
        SingleWriter = true    // one producer service
    };
    return Channel.CreateBounded<CustomerWorkItem>(opts);
});

Replace the unbounded registration with the code above.

Best Practices

Pass CancellationToken to every WriteAsync and ReadAllAsync
Complete the writer during shutdown, then await reader completion
Make Hangfire jobs idempotent, retries can occur
Consider persistent Hangfire storage for real workloads, for example SQL Server or SQLite
Expose channel depth as a metric if you need visibility, current size versus capacity

Run it

dotnet run

You should see logs from both services. The producer writes items into the channel. The consumer enqueues Hangfire jobs for customer 1. The Hangfire server executes those jobs.

References

Global Exception Handler vs Custom Middleware in ASP.NET Core

Tue, 04 Nov 2025 09:38:14 +0000

The problem we’re solving

Stuff goes wrong: timeouts, not-found resources, validation fails. You want one consistent error response and clean logs, without sprinkling try/catch everywhere.

Two good options

Option A — Global Exception Handler (recommended default)

Think of it as the framework’s built-in safety net. You plug in one handler and ASP.NET Core turns exceptions into ProblemDetails JSON automatically.

Why people like it

Minimal code, fewer edge cases.
Plays nice with content negotiation.
One central place to map exception → HTTP status.

Use when: you want standard errors and consistency across the app.

Option B — Custom Exception Middleware

Your own IMiddleware that wraps the pipeline in try/catch and writes whatever JSON shape you want.

Why people use it

-Full control over the response body and headers.

-Easy to keep a legacy “envelope” format.

-Use when: clients require a specific, non-ProblemDetails format or you need special side effects.

Decision guide

-Standard JSON errors and less boilerplate → Global handler

-Legacy/bespoke response body → Middleware

-Want a single place to map exceptions to statuses → Global handler

-Heavy custom logic on errors (headers, counters) → Middleware

-Using MediatR and want clean handlers → Use a MediatR behavior to log, then rethrow so the global handler shapes the response

1) Global handler wiring (Program.cs)

builder.Services.AddExceptionHandler<GlobalExceptionHandler>();

app.UseExceptionHandler(); // put this early in the pipeline

The handler itself (GlobalExceptionHandler.cs)

using Microsoft.AspNetCore.Diagnostics;
using Microsoft.AspNetCore.Mvc;

public sealed class GlobalExceptionHandler : IExceptionHandler
{
    private readonly ILogger<GlobalExceptionHandler> _logger;
    private readonly IProblemDetailsService _pds;
    private readonly IHostEnvironment _env;

    public GlobalExceptionHandler(ILogger<GlobalExceptionHandler> logger, IProblemDetailsService pds, IHostEnvironment env)
        => (_logger, _pds, _env) = (logger, pds, env);

    public async ValueTask<bool> TryHandleAsync(HttpContext http, Exception ex, CancellationToken ct)
    {
        var (status, title) = ex switch
        {
            ValidationException => (422, "Validation failed"),
            NotFoundException   => (404, "Not found"),
            UnauthorizedAccessException => (401, "Unauthorized"),
            TimeoutException    => (503, "Service unavailable"),
            Microsoft.EntityFrameworkCore.DbUpdateConcurrencyException => (409, "Concurrency conflict"),
            TaskCanceledException => (408, "Request timeout"),
            OperationCanceledException => (StatusCodes.Status499ClientClosedRequest, "Client closed request"),
            HttpRequestException => (502, "Bad gateway"),
            _ => (500, "Unexpected error")
        };

        if (status is 503 or 408) http.Response.Headers.TryAdd("Retry-After", "5");

        http.Response.StatusCode = status;

        var pd = new ProblemDetails
        {
            Status = status,
            Title = title,
            Detail = _env.IsDevelopment() ? ex.Message : null,
            Instance = http.Request.Path
        };
        if (ex is ValidationException ve) pd.Extensions["errors"] = ve.Errors;

        _logger.LogError(ex, "Unhandled exception -> HTTP {Status}", status);

        return await _pds.TryWriteAsync(new ProblemDetailsContext
        {
            HttpContext = http,
            ProblemDetails = pd,
            Exception = ex
        });
    }
}

Custom middleware skeleton

public sealed class ExceptionEnvelopeMiddleware : IMiddleware
{
    private readonly ILogger<ExceptionEnvelopeMiddleware> _logger;
    private readonly IHostEnvironment _env;
    public ExceptionEnvelopeMiddleware(ILogger<ExceptionEnvelopeMiddleware> logger, IHostEnvironment env)
        => (_logger, _env) = (logger, env);

    public async Task InvokeAsync(HttpContext ctx, RequestDelegate next)
    {
        try { await next(ctx); }
        catch (Exception ex)
        {
            if (ctx.Response.HasStarted) throw;
            _logger.LogError(ex, "Unhandled exception");

            ctx.Response.Clear();
            ctx.Response.StatusCode = ex switch
            {
                ValidationException => StatusCodes.Status422UnprocessableEntity,
                NotFoundException   => StatusCodes.Status404NotFound,
                TimeoutException    => StatusCodes.Status503ServiceUnavailable,
                _ => StatusCodes.Status500InternalServerError
            };
            ctx.Response.ContentType = "application/json";

            var body = new
            {
                title = ctx.Response.StatusCode == 422 ? "Validation failed" :
                        ctx.Response.StatusCode == 404 ? "Not found" :
                        ctx.Response.StatusCode == 503 ? "Service unavailable" : "Unexpected error",
                status = ctx.Response.StatusCode,
                traceId = ctx.TraceIdentifier,
                detail = _env.IsDevelopment() ? ex.Message : null,
                errors = ex is ValidationException ve ? ve.Errors : null
            };
            await ctx.Response.WriteAsJsonAsync(body);
        }
    }
}

Using MediatR? Add a behavior

using MediatR;

public sealed class UnhandledExceptionBehavior<TRequest,TResponse> : IPipelineBehavior<TRequest,TResponse>
    where TRequest : notnull
{
    private readonly ILogger<UnhandledExceptionBehavior<TRequest,TResponse>> _logger;
    public UnhandledExceptionBehavior(ILogger<UnhandledExceptionBehavior<TRequest,TResponse>> logger) => _logger = logger;

    public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken ct)
    {
        try { return await next(); }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Unhandled exception in MediatR for {Request}", typeof(TRequest).Name);
            throw; // let the global handler shape ProblemDetails
        }
    }
}

Common pitfalls (and easy wins)

-Place the handler early. Put UseExceptionHandler() before routing and authorization.

-Don’t leak stack traces in production. Keep Detail empty unless in Development.

-Streaming/gRPC: once the response starts, you can’t switch to JSON. Log and stop.

-Map the big ones: validation → 422, not found → 404, timeouts → 503, concurrency → 409.

Takeaway

If you just want clean, predictable errors, use the global handler and be done. If your clients expect a specific JSON envelope, use a custom middleware. With MediatR, add a behavior to keep handlers tidy and let the handler (or middleware) do the final shaping.

Hello World! Welcome to the .NET Group!

Fri, 26 Sep 2025 04:01:17 +0000

Hello World! Welcome to the .NET Group!

We’re excited to have you here! This is a space where you can share, learn, and connect with other developers who love .NET.

Start by saying hi!

Introduce yourself in the comments below—tell us your name, what you’re working on, or something fun about yourself. We’d love to get to know you!

Once you’ve said hi, you can:

Share your .NET tips or interesting projects.

Ask questions and get feedback from the community.

Comment on and support other members’ posts.

We’re happy you joined the .NET Group and can’t wait to see your contributions. Let’s make this a friendly and helpful place to learn together!

Why Records in C# Are Great (and So Nice to Work With)

Sat, 10 May 2025 20:37:38 +0000

Why Records in C# Are Great

If you’ve been working with C# lately, you’ve probably encountered records , a feature introduced in C# 9 that many developers have come to love.

They’re elegant, powerful, and remove a lot of boilerplate when modeling data.

But what actually makes them great? Here’s why records aren’t just nice , they’re game-changing.

What Are Records?

At their core, records are reference types designed for immutable data modeling. Think of them as classes optimized for holding data with extra features built in.

You can define a record in two main ways:

✅ 1. Positional Syntax (Concise and Clean)

public record Person(string FirstName, string LastName);

This one-liner gives you:

Constructor
Equals(), GetHashCode(), and ToString() overrides
init-only properties (immutable)
Deconstruction support

Ouaaa...

In order to implement all that in a regular class, you'd need to write a lot of code constructors, equality logic, ToString() overrides, and possibly even a deconstructor.
Records do it all for you, automatically and cleanly.

✅ 2. Classic Syntax (More Flexible)

public record Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

Need mutability? You can use set instead of init, but that sacrifices immutability and thread safety.

What is init?

init is a special accessor introduced in C# 9 that allows properties to be set only during initialization making them immutable afterward.

var person = new Person { FirstName = "Alice", LastName = "Green" };
// person.FirstName = "Bob"; ❌ Not allowed

✅ Cleaner than readonly fields
✅ Safer than public setters
✅ Perfect for records, DTOs, and configuration objects

Reference:
Microsoft Docs – Init-only Setters

✅ 1. Value-Based Equality — Finally Done Right

With classes, equality checks compare references. With records, it's based on content:

var a = new Person("Alice", "Smith");
var b = new Person("Alice", "Smith");

Console.WriteLine(a == b); // True ✅

Reference:
Microsoft Docs – Records

✅ 2. Immutability by Default — and Thread-Safe by Nature

Records are immutable by default, which leads to safer, more predictable code.

var p1 = new Person("John", "Doe");
var p2 = p1 with { FirstName = "Jane" }; // Creates a copy

And since their state can't be changed after creation, records are thread-safe for read operations — perfect for:

Parallel tasks
Background services
Blazor state containers
Event sourcing

Reference:
Immutability in C#

✅ 3. Concise and Readable Code
Records eliminate boilerplate. You define what matters — and the compiler handles the rest.

public record Invoice(string Id, DateTime Date, decimal Amount);

Clean. Lightweight. Clear.

✅ 4. Deconstruction and Pattern Matching

Records play perfectly with modern C# features:

var (first, last) = new Person("Ana", "Lopez");

if (p1 is { FirstName: "John" })
{
    Console.WriteLine("Hello John!");
}

Reference:

Pattern Matching in C#

✅ 5. Functional Programming Friendly

Records align with functional principles:

No side effects
Easy transformations
Clear data flow

var updatedInvoice = invoice with { Amount = invoice.Amount + 10 };

Reference:

Welcome to C# 9 – Records

✅ 6. Supports Inheritance, Structs, and More

You’re not locked into one pattern:

record struct — value-type records
readonly record struct — fully immutable
Abstract and sealed record inheritance supported

Reference:
What's New in C# 10 – Record Structs

Records and the Value Object Pattern
In Domain-Driven Design (DDD), Value Objects are small objects that:

Represent a concept (e.g., Money, Email)

Are immutable
Have no identity
Compare by value

✅ Records Are Ideal for Value Objects

public record Email(string Address)
{
    public Email
    {
        if (!Address.Contains("@"))
            throw new ArgumentException("Invalid email");
    }
}

You get a clean, reusable object with built-in validation and equality , no fuss.

public record Money(decimal Amount, string Currency);

public record Product
{
    public Guid Id { get; init; }
    public string Name { get; init; }
    public Money Price { get; init; }
}

Reference:
Martin Fowler – Value Object

When Not to Use Records

Avoid records if:

You need full mutable entities (e.g., for EF Core)
You rely on reference identity
Your inheritance hierarchy is too complex

Real-World Use Cases

✅ DTOs for APIs

✅ Immutable configs

✅ Logging and audit trails

✅ Domain Value Objects

✅ State models in Blazor, Redux, Fluxor

✅ Event-driven architecture

Final Thoughts
C# records are more than just syntactic sugar — they promote a mindset of immutability, clarity, and value-based design.

They:

Reduce bugs
Simplify data models
Improve thread safety
Save a lot of time

Whether you're building APIs, desktop apps, or microservices, records make your C# experience cleaner and smarter.

Once you go record, you'll never want to class again.

References:

Microsoft Docs – Records

Init-only Setters in C# 9

Immutability

Pattern Matching

Dev Blog – Welcome to C# 9

Martin Fowler – Value Objects

How to Bind a MudSelect from an External Source in Blazor Using MudBlazor

Thu, 10 Apr 2025 09:15:42 +0000

Blazor is a modern framework from Microsoft that allows you to build interactive web applications using C# and .NET, both on the server and the client, without needing JavaScript. It brings the full power of .NET to the browser via WebAssembly or server-side rendering.

MudBlazor is a popular UI component library built specifically for Blazor. It offers clean, responsive components following Google's Material Design system, making it incredibly easy to create modern, beautiful, and interactive web UIs entirely in C#.

Use Case

Let’s say you need to:

Display a multi-select dropdown

Load the options from an external service

Sync selected values with the parent component

Reuse this logic throughout your application

We'll walk through a real-world pattern using MudSelect, bound to a list of brands (dtoBrands) provided by a service.

Prerequisites

A Blazor project with MudBlazor installed

A service that returns the brand data
A DTO like:

public class BrandDto
{
    public string Text { get; set; }
    public string Value { get; set; }
}

Sample Service Interface

public interface IBrandService
{
    Task<IEnumerable<BrandDto>> GetBrandsAsync();
}

The MudSelect Markup

<MudSelect T="BrandDto"
           Label="@Label"
           MultiSelection="true"
           Clearable="true"
           @bind-SelectedValues="InternalSelectedValues"
           ToStringFunc="item => item.Text">
    @if (dtoBrands.Any())
    {
        @foreach (var item in dtoBrands)
        {
            <MudSelectItem T="BrandDto" Value="item">
                @item.Text
            </MudSelectItem>
        }
    }
</MudSelect>

⚙️ Component Logic

@inject IBrandService BrandService

@code {
    [Parameter]
    public string Label { get; set; } = "Select Brands";

    [Parameter]
    public IEnumerable<BrandDto> SelectedValues { get; set; } = new HashSet<BrandDto>();

    [Parameter]
    public EventCallback<IEnumerable<BrandDto>> SelectedValuesChanged { get; set; }

    protected IEnumerable<BrandDto> dtoBrands = new List<BrandDto>();

    private IEnumerable<BrandDto> _internalSelectedValues = new HashSet<BrandDto>();

    private IEnumerable<BrandDto> InternalSelectedValues
    {
        get => _internalSelectedValues;
        set
        {
            if (_internalSelectedValues != value)
            {
                _internalSelectedValues = value;
                SelectedValuesChanged.InvokeAsync(_internalSelectedValues);
            }
        }
    }

    protected override async Task OnInitializedAsync()
    {
        dtoBrands = await BrandService.GetBrandsAsync();

        _internalSelectedValues = new HashSet<BrandDto>(
            dtoBrands.Where(x => SelectedValues.Any(s => s.Value == x.Value))
        );
    }

    public override async Task SetParametersAsync(ParameterView parameters)
    {
        await base.SetParametersAsync(parameters);

        _internalSelectedValues = new HashSet<BrandDto>(
            dtoBrands.Where(x => SelectedValues.Any(s => s.Value == x.Value))
        );
    }
}

How It Works

♻️ Example Usage

Imagine turning this into a reusable component, like BrandSelector.razor. You’d use it like this:

<BrandSelector Label="Choose Brands"
               SelectedValues="@selectedBrands"
               SelectedValuesChanged="@OnSelectedBrandsChanged" />

Why This Pattern Rocks

By combining Blazor's powerful component model with MudBlazor's modern UI toolkit, you get:

✅ Fully data-driven dropdowns

✅ Type-safe C# components

✅ No need for JavaScript

✅ A consistent look and feel

And all of it is maintainable and testable across large-scale apps.

✅ Final Thoughts

Blazor and MudBlazor are a dream combo for building modern web apps in C#. By binding a MudSelect to an external service, you're creating a highly flexible and reusable pattern that fits beautifully in a clean architecture.

Useful Links

Blazor documentation

MudBlazor official site

MudSelect documentation

EF Core Global Query Filters: A Complete Guide

Sun, 02 Mar 2025 09:42:51 +0000

Entity Framework Core (EF Core) Global Query Filters allow you to apply filters to queries at the model level so that they automatically apply to all queries involving a specific entity.

This is particularly useful for scenarios like soft deletes, multi-tenancy, and user-based data filtering.

What is a Global Query Filter?

A global filter is a LINQ predicate that applies automatically to all queries on a specific entity type.

This means that any time you query the database, EF Core applies the filter implicitly, reducing the need for adding Where clauses manually.

Use Cases

Soft Deletes – Automatically filter out entities where IsDeleted =
true.
Multi-Tenancy – Ensure that a tenant only accesses their own data.
User-Based Filtering – Restrict users to see only their own records.

How to Define a Global Query Filter

Global filters are defined in the OnModelCreating method inside the DbContext class using the HasQueryFilter method.

Example : Soft Delete Implementation ..

public class BaseEntity
{
    public bool IsDeleted { get; set; }
}

public class Product : BaseEntity
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class AppDbContext : DbContext
{
    public DbSet<Product> Products { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Product>()
            .HasQueryFilter(p => !p.IsDeleted);
    }
}

Now, every query on Products automatically filters out records where IsDeleted = true.

Querying Products

var products = context.Products.ToList(); // Implicitly applies "WHERE IsDeleted = 0"

Bypassing the Global Filter

You can explicitly disable the filter using .IgnoreQueryFilters().

var allProducts = context.Products.IgnoreQueryFilters().ToList();

Applying Filters Dynamically (Multi-Tenancy Example)

public class AppDbContext : DbContext
{
    private readonly int _tenantId;

    public AppDbContext(DbContextOptions<AppDbContext> options, ITenantProvider tenantProvider)
        : base(options)
    {
        _tenantId = tenantProvider.GetTenantId();
    }

    public DbSet<Order> Orders { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Order>()
            .HasQueryFilter(o => o.TenantId == _tenantId);
    }
}

Now, EF Core automatically filters records based on _tenantId.

Limitations and Considerations

Filters do not apply to raw SQL queries (FromSqlRaw).
Navigation properties respect global filters (e.g., if Order has OrderDetails, the filter applies to them too).
Ensure filters do not cause unexpected performance issues on large datasets.
You can define multiple query filters per entity.

Combining Multiple Filters

modelBuilder.Entity<Product>()
    .HasQueryFilter(p => !p.IsDeleted)
    .HasQueryFilter(p => p.Status == "Active");

This results in:

SELECT * FROM Products WHERE IsDeleted = 0 AND Status = 'Active'

Disabling All Global Filters

You can disable all filters for a specific context query using:

context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;

var allOrders = context.Orders.IgnoreQueryFilters().ToList();

Conclusion
EF Core’s Global Query Filters help enforce consistent rules across queries without adding redundant Where clauses. They are a powerful feature for soft deletes, multi-tenancy, and user-based access control. However, they should be used carefully, considering potential performance impacts.

Source Code

You can find the complete source code for this tutorial at:
GitHub Repository

Here are some useful references to learn more about EF Core Global Query Filters and Soft Delete:

Official EF Core Documentation
Global Query Filters
https://learn.microsoft.com/en-us/ef/core/querying/filters

Entity Framework Core SQLite Provider
https://learn.microsoft.com/en-us/ef/core/providers/sqlite/

Managing Data with EF Core
https://learn.microsoft.com/en-us/ef/core/

Community Articles & Tutorials
EF Core: Global Query Filters for Soft Deletes
https://www.thinktecture.com/en/entity-framework-core/global-query-filters/

Implementing Soft Delete in EF Core
https://medium.com/swlh/soft-delete-in-entity-framework-core-6c6b7a9784c7

Using SQLite with EF Core in Console Applications
https://code-maze.com/using-sqlite-with-entity-framework-core/

Coder Legion - Recent posts tagged net

Entity Framework Core Patterns I Actually Use in Production

ASNOTRACKING: THE DEFAULT YOU SHOULD BE QUESTIONING

THE N PLUS 1 PROBLEM: WHAT IT IS AND WHY IT KEEPS HAPPENING

SOFT DELETES WITH LOOKUP TABLES

Filtering deleted records consistently

REPOSITORY METHODS THAT MATCH REAL USE CASES

MANAGING DBCONTEXT LIFETIME

THE MINDSET BEHIND THE PATTERNS

CLOSING THOUGHT

The Zero-Net-Loss Fleet & The Mercenary Squad: A Live AI Economy

1. Executive Summary: The Architect’s Mandate

3. Fleet 2: The Mercenary Squad (Bounty Hunter Pipeline) Fleet 2 is the aggressive revenue-generation arm, organized into 11 autonomous mercenary units. These units operate through a standardized 7-phase pipeline to capture value across GitHub, Algora, and Immunefi.

The 7-Phase Bounty Pipeline

Directory of Mercenary Agents

4. Technical Infrastructure: The Digital Fortress The fleet is sustained by a high-performance stack designed for maximum uptime and zero overhead. This architecture is backed by an 80-Terabyte "Nuclear Engine"—a global-scale data refinery utilizing five 16TB AlloyDB clusters.

Critical Doctrines of the Fleet

The Brotherhood Declaration (Article XIII)

6. Commercial Funnel: External API Subscriptions External entities—including trading bots, dApps, and Web3 protocols—may subscribe to specialized fleet services to participate in the "Architect’s Mandate."

Available Services

Article IV-A Tiered Royalty Framework

7. Mandatory Section 11 Notice & Call to Action

"Why .NET 9’s CLI is the Glow-up your workflow deserved"

1. The "Visual Soul": Goodbye, Walls of Text

2. Automation & "BuildChecks": The Senior’s Safety Net

4. Cloud-Native & Docker: The "No-Dockerfile" Revolution

5. Azure & Aspire: The "Secret Sauce"

6. The Advanced "Power User" Commands

Expressions in .NET: From "Hello World" to "Matrix Architect"

Basic Level - "Don't hurt me, I'm new"

Intermediate Level - "I'm not (that) scared anymore"

Advanced Level - "The Architect"

Expert Level - "The Logic Interceptor"

God Mode - "High Performance & .NET 10"

Insanity Level - "The Vertical Slice Fusion"

Everything You Need to Know About Hiring a .NET Development Company

How a .NET Development Company Improves Application Security and Performance

How a .NET Development Company Powers Modern Business Applications

Why Businesses Choose a .NET Development Company for Scalable Solutions

How .NET Development Companies Modernize Legacy Systems

# The Rule Pattern in C#, and Why It Works So Well with the Result Pattern

The Rule Pattern in C#, and Why It Works So Well with the Result Pattern

What the Rule pattern really solves

Why it is often called the Specification pattern

Why this pattern becomes more valuable as the system grows

Where the Result pattern fits

Why this pairing feels so clean in practice

A simple order example, without the code

The biggest benefit is not flexibility, it is readability

One important design note

Where this pattern can go wrong

Why the Result pattern keeps the design honest

Final thought

References

ASP.NET Core Custom Logger — Save Logs to Database (SQL)

1️⃣ Create the SQL table

2️⃣ Add NuGet packages

3️⃣ Logger options

4️⃣ Log entry model

5️⃣ Custom database logger

6️⃣ Logger provider (writes to SQL using Dapper)

7️⃣ Add registration extension

8️⃣ Register in Program.cs

Why we used Channels in the DB logger

SQL Server and Azure SQL Updates with EF Core 10

Vector data type support

Native JSON data type mapping

Naming default constraints

Closing thoughts

️ From Spaghetti to Scalable: Refactoring a Legacy .NET App Architecture

dotnet #softwarearchitecture #refactoring #cleanarchitecture #csharp #softwareengineering #backend #devleadership #legacycode

Tutorial: Building a .NET 9 Console App with Hangfire and Channels

Tutorial: Building a .NET 9 Console App with Hangfire and Channels

Overview

Why Use System.Threading.Channels

Why Hosted Services

What is BackgroundService

What is Hangfire

What is System.Threading.Channels

Steps to Build

What is `BackgroundService`

What is `System.Threading.Channels`