DEV Community: Ahmed Shah

C# 14's field Keyword: Property Validation Without a Backing Field

Ahmed Shah — Sun, 11 Oct 2026 16:36:59 +0000

In the previous post we looked at https://dev.to/ahmedshahjr/should-you-migrate-to-net-10-today-an-honest-lts-decision-guide-5758 Once you target .NET 10, you also get C# 14.

This post starts a new 4-part series: C# 14 & Modern C# Deep Dive. Part 1 is about one small keyword that we will use almost every day: field.

In this post we will learn about:

The old way: a private backing field just to add one check
What the field keyword is and how to enable it
Before and after code, plus lazy and trim examples
The rules and the three gotchas to know before you upgrade
In C# 14, field inside a property accessor means "the backing field the compiler made for this property".
You can add validation or normalization to a property without declaring a private field and without writing the get body.
Watch out for three things: initializers skip the setter, field works only inside that property, and an existing member named field changes meaning.

The problem: a private field just to add one check

Here is a property we have all written many times. We want a Price that is never negative. An auto property ({ get; set; }) can't do that, so we add a private field and write both accessors.

// Before/Product.cs
namespace FieldKeywordDemo.Before;

public class Product
{
    private decimal _price;

    public decimal Price
    {
        get => _price;
        set => _price = value >= 0
            ? value
            : throw new ArgumentOutOfRangeException(nameof(value), "Price must not be negative.");
    }

    public void ApplyDiscount(decimal percent)
    {
        // Compiles fine, but skips the check in the setter
        _price -= _price * percent / 100;
    }
}

This works, but notice two things:

We wrote a field and a get body only to add one line of logic to the setter.
_price is visible to the whole class. ApplyDiscount writes to it directly, so a 150% discount gives a negative price, and the setter never runs.

The feature specification names this second point too: the backing field leaks into the rest of the type, and code can bypass the accessors by accident.

What is the `field` keyword?

field is a contextual keyword added in C# 14. Inside a property accessor, it refers to the backing field that the compiler creates for that property. You don't declare it, and you don't name it.

A property that uses field is called a field-backed property.

How to enable it:

Target net10.0. The default language version for .NET 10 is C# 14, so there is nothing else to set.
You need the .NET 10 SDK or Visual Studio 2026.

Note: field was a preview feature in C# 13. In C# 14 it is a regular, supported feature. Microsoft says using a newer C# version than your target framework's default is unsupported, so don't set LangVersion to 14 on a .NET 8 project.

Before and after

Here is the same Product with field:

// After/Product.cs
namespace FieldKeywordDemo.After;

public class Product
{
    public decimal Price
    {
        get;
        set => field = value >= 0
            ? value
            : throw new ArgumentOutOfRangeException(nameof(value), "Price must not be negative.");
    }

    public void ApplyDiscount(decimal percent)
    {
        // There is no private field to reach, so this goes through the setter
        Price -= Price * percent / 100;
    }
}

What changed:

No _price field. The compiler creates the backing field for us.
get; stays automatic. We mix an auto accessor (get;) with a full accessor (set => ...). Before C# 14 this was not allowed.
The check can't be skipped from other methods. ApplyDiscount must use Price, so the setter always runs.

Per property, we remove one field declaration and one hand-written accessor. For a class with many validated properties, that adds up.

Two more everyday patterns

Trim and normalize input

Emails, usernames and codes often need cleaning before we store them. This pattern is from the What's new in C# 14 page:

// After/Customer.cs
namespace FieldKeywordDemo.After;

public class Customer
{
    public string Email
    {
        get;
        set => field = value?.Trim()?.ToLowerInvariant() ?? string.Empty;
    } = string.Empty;
}

The = string.Empty initializer gives the backing field a start value, so the nullable checker is happy. (More on initializers below, because they have a catch.)

Lazy loading

A get-only or expression-bodied property can also use field. With ??=, the value is created on first read and then reused:

// After/CurrencyService.cs
namespace FieldKeywordDemo.After;

public class CurrencyService
{
    public string[] Currencies => field ??= LoadCurrencies();

    private static string[] LoadCurrencies()
    {
        Console.WriteLine("Loading currencies...");
        return ["USD", "EUR", "GBP"];
    }
}

Let's run the demo and see the results:

// Program.cs
using FieldKeywordDemo.After;

var product = new Product { Price = 100m };
product.ApplyDiscount(10);
Console.WriteLine($"Price after discount: {product.Price}");

var customer = new Customer { Email = "  Ahmed@Example.COM " };
Console.WriteLine($"Email: '{customer.Email}'");

var service = new CurrencyService();
Console.WriteLine(service.Currencies.Length);
Console.WriteLine(service.Currencies.Length); // "Loading..." prints only once

try
{
    product.ApplyDiscount(150);
}
catch (ArgumentOutOfRangeException ex)
{
    Console.WriteLine(ex.Message);
}

Price after discount: 90
Email: 'ahmed@example.com'
Loading currencies...
3
3
Price must not be negative. (Parameter 'value')

As you can see, "Loading currencies..." prints only once, and the 150% discount now throws instead of saving a negative price.

Note: field ??= ... is not thread-safe. If two threads read the property at the same time, LoadCurrencies can run twice. For shared objects (singletons in ASP.NET Core, for example), use the Lazy type instead.

The rules you need to know

From the language reference and the feature specification:

Mix and match accessors. { get; set => ... }, { get => ...; set; } and two full accessors all work.
Get-only and expression-bodied properties can use field (like the lazy example).
{ set; } alone is still not allowed, same as before.
field works only in property accessors. It is not a keyword in indexers or event accessors, and other methods in the class can't see the backing field.
Use nameof(value), not nameof(field), in exceptions. nameof(field) doesn't compile.
Field-targeted attributes work: [field: SomeAttribute] goes on the hidden backing field, as with auto properties.

Gotcha 1: initializers don't call the setter

A property initializer writes directly to the backing field. The setter does not run.

// After/Settings.cs
namespace FieldKeywordDemo.After;

public class Settings
{
    public bool HasChanges { get; private set; }

    public string Theme
    {
        get;
        set
        {
            field = value;
            HasChanges = true;
        }
    } = "light"; // sets the backing field only, HasChanges stays false
}

Often this is what we want: the default value should not count as a "change". But if your setter validates, the initializer value is not validated.

If you want the setter to run for the start value, assign it in the constructor instead. A constructor assignment calls the setter.

Gotcha 2: a member already named `field`

This is the breaking change to check when you upgrade. If your class already has a member called field, then inside a property accessor the word field now means the backing field, not your member.

// Legacy/Sensor.cs
namespace FieldKeywordDemo.Legacy;

public class Sensor
{
    private double field = 0; // an old member, named "field" by chance

    // C# 14: warning CS9258. This now reads a NEW backing field, not the member above.
    public double Reading => field;

    // Fix: say which one you mean (or rename the member)
    public double ReadingFixed => this.field; // or @field
}

Building this sample with the .NET 10 SDK gives:

Legacy\Sensor.cs(8,30): warning CS9258: In language version 14.0, the 'field' keyword binds to a synthesized backing field for the property. To avoid generating a synthesized backing field, and to refer to the existing member, use 'this.field' or '@field' instead.

The compiler gives warning CS9258 when field would have meant something else in C# 13. Don't ignore it: the code still compiles, but it reads a different value.
A local variable named field inside an accessor is now error CS9272. Rename it or use @field.
The cleanest fix is to rename the old member.

Tip: before upgrading a big solution, search for the word field used as a name. It is rare, but generated code and old DTOs sometimes have it.

When to keep an explicit backing field

field doesn't replace every private field. Here is a simple way to decide:

flowchart TD
    A[Does the property need any logic?] -- No --> B[Auto property: get; set;]
    A -- Yes --> C{Do other methods need<br/>the raw value, not the property?}
    C -- Yes --> D[Keep an explicit private field]
    C -- No --> E{Lazy value read by<br/>many threads?}
    E -- Yes --> F[Use the Lazy type]
    E -- No --> G[Use the field keyword]

Keep an explicit field when another method must reset or read the raw value without going through the property (for example, a Clear() method that bypasses validation on purpose). The field keyword can't help there.

Key takeaways

field gives you the compiler-made backing field inside a property accessor, in C# 14 / .NET 10.
Use it for validation, normalization and simple lazy loading, without a private field.
Initializers skip the setter; constructor assignments don't.
Fix CS9258 warnings with this.field, @field or a rename.
Keep an explicit field when other methods need the raw value, and use the Lazy type for thread-safe lazy loading.

This is a small demo for learning, not a full guide to every rule. The feature specification covers structs, nullability and overrides in detail.

The sample code is on GitHub:

ahmedshahjr / Articles

Direct link to the sample folder: csharp-14-field-keyword

In the next part (Thursday, October 15) we will look at Extension Members in C# 14: extension properties are finally here.

Do you have a class in your codebase where field would remove a backing field today, or do you prefer to keep the explicit field?

Should You Migrate to .NET 10 Today? An Honest LTS Decision Guide

Ahmed Shah — Sun, 11 Oct 2026 14:43:43 +0000

.NET 8 and .NET 9 both reach end of support on November 10, 2026. That is about five weeks from today.

Many of us still run services on .NET 8. It was the safe LTS choice, and it worked well. So the real question now is not "should we move?" but "how fast, and to which version?"

In this post we will learn about:

The dates that matter, from Microsoft's own support policy
What "end of support" really means for your apps on Azure
A simple decision guide: migrate now, migrate soon, or wait
The migration steps we follow, and the pitfalls to watch for
.NET 10 is LTS and is supported until November 14, 2028.
.NET 8 (LTS) and .NET 9 (STS) end on the same day: November 10, 2026.
For most production services, move to .NET 10 now. Do not wait for .NET 11.

The dates that matter

Here are the dates from the official .NET support policy (last updated September 8, 2026):

Version	Type	Released	End of support
.NET 8	LTS	Nov 14, 2023	Nov 10, 2026
.NET 9	STS	Nov 12, 2024	Nov 10, 2026
.NET 10	LTS	Nov 11, 2025	Nov 14, 2028
.NET 11	STS	Nov 2026 (RC1 out now)

Note: .NET 9 was first planned to end in May 2026. During its life, Microsoft extended STS support from 18 to 24 months. That is why .NET 8 and .NET 9 now end together.

LTS means Long Term Support (three years). STS means Standard Term Support (now two years). The quality of both is the same. Only the support length is different.

What "end of support" really means

Your app will not stop on November 11. It keeps running.

But after that date:

No more security patches for that runtime
No Microsoft support if something breaks
Security scanners and audits start to flag it

On Azure App Service, apps on an old runtime keep running, but App Service can't give security patches or support for that runtime after its end-of-support date.

On Azure Functions, check two things. .NET 8 and .NET 9 workers end on the same date. And the in-process model for .NET Functions also ends support on November 10, 2026. If you still use in-process Functions, plan the move to the isolated worker model together with the version upgrade.

The decision guide

flowchart TD
    A[Service on .NET 8 or 9] --> B{Is it in production<br/>and still maintained?}
    B -- No, retiring soon --> W[Fine to wait.<br/>Retire it, or isolate it]
    B -- Yes --> C{Do all key packages<br/>support .NET 10?}
    C -- Yes --> N[Migrate now to .NET 10]
    C -- Not yet --> S[Migrate soon.<br/>Track the blocker, upgrade the rest]
    N --> T[Target .NET 10 LTS,<br/>not .NET 11 STS]
    S --> T

Migrate now

The service is in production and you will keep changing it.
It faces the internet, or it handles payments or personal data.
Your main packages (EF Core, your message bus client, your auth library) already support .NET 10.

Migrate soon (but start this week)

One important third-party package is not ready yet. Upgrade everything else, and keep a short list of blockers.
You have many microservices. Start with one small, low-risk service and learn from it.

It's fine to wait

The app will be retired soon, and it is not exposed to the internet.
It is a .NET Framework app. That is a different support track and a different (bigger) migration.

Be honest with this last group. "We will retire it next year" often becomes three more years.

Why .NET 10 and not .NET 11?

.NET 11 ships in November 2026, at .NET Conf (November 10 to 13). It is an STS release.

So why not wait and jump straight to .NET 11?

.NET 11 GA arrives on the same day .NET 8 support ends. Waiting leaves no buffer for testing.
Your packages need time to support a new version. .NET 10 has had almost a year.

If your team likes the newest features and upgrades every year, .NET 11 is a fine next step after you are on .NET 10. Going 8 to 10 now, then 10 to 11 later, is a much smaller jump each time.

Step-by-step migration

These are the steps we follow for one service. The sample config is in my repo (link at the end).

1. Install the SDK and pin it with global.json

Install the latest .NET 10 SDK. Then pin it, so every developer and the CI pipeline use the same SDK.

// global.json
{
  "sdk": {
    "version": "10.0.100",
    "rollForward": "latestFeature"
  }
}

Note: rollForward: latestFeature lets the build use a newer 10.0 SDK feature band if one is installed,

2. Change the target framework in one place

If you have many projects, put the target framework in Directory.Build.props at the solution root. Then one line upgrades every project.

<!-- Directory.Build.props -->
<Project>
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <CheckSdkVulnerabilities>true</CheckSdkVulnerabilities>
  </PropertyGroup>
</Project>

Note: remove <TargetFramework> from each .csproj, or it will override this value.

CheckSdkVulnerabilities makes the build warn when the SDK you build with has known vulnerabilities (NETSDK1238) or is end of life (NETSDK1239). The check arrives with the .NET 11 SDK (Preview 5 and later); the .NET 10 SDK ignores the property, so today it does nothing. It is a cheap safety net for the next migration.

3. Update the Microsoft packages

Update every Microsoft.* package that follows the runtime version (ASP.NET Core, EF Core, Extensions) to 10.0.x. Then check what else is outdated or vulnerable:

# from the solution folder
dotnet list package --outdated
dotnet list package --vulnerable --include-transitive

4. Read the breaking changes (really)

Microsoft keeps a full list of breaking changes in .NET 10. For microservices, these are the ones I would check first:

Default .NET container images use Ubuntu (not Debian). If your Dockerfile runs apt-get or depends on OS packages, test it.
System.Linq.AsyncEnumerable is now in the core libraries. If you use the System.Linq.Async package, you can get conflicts.
BackgroundService runs all of ExecuteAsync as a Task. Check workers that did blocking work before their first await.
Null values are preserved in configuration. Check options classes that relied on nulls being dropped.
dotnet restore audits transitive packages. Your build may show new vulnerability warnings, which is a good thing.

Also read ASP.NET Core 10 breaking changes and EF Core 10 breaking changes if you use them.

5. Update the Docker base images

# Dockerfile
FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish ./src/OrderService/OrderService.csproj -c Release -o /app

FROM mcr.microsoft.com/dotnet/aspnet:10.0
WORKDIR /app
COPY --from=build /app .
ENTRYPOINT ["dotnet", "OrderService.dll"]

6. Update the CI pipeline

# .github/workflows/build.yml (only the setup step)
- uses: actions/setup-dotnet@v4  
  with:
    global-json-file: global.json

Reading the version from global.json means you change the SDK in one place only.

7. Update the Azure runtime setting

For App Service on Linux, change the stack to .NET 10:

az webapp config set --name <app-name> --resource-group <rg-name> --linux-fx-version "DOTNETCORE|10.0"

For Azure Functions, move to the isolated worker model first if you are still in-process, then target net10.0.

8. Run the tests, then deploy one service first

Run all tests. Then deploy one small service to a test environment and watch logs and metrics for a day before moving the rest.

Should a tool do this for me?

Microsoft now recommends GitHub Copilot app modernization for upgrades. It analyzes your solution, writes an upgrade plan, and commits each change so you can review or roll it back.

The older .NET Upgrade Assistant is officially deprecated. Use it only if you can't use the new agent.

My honest view: a tool can do the boring edits. But you still need to read the breaking changes and test your own service. The tool doesn't know your production traffic.

Key takeaways

.NET 8 and .NET 9 both end on November 10, 2026.
.NET 10 (LTS, until November 14, 2028) is the safe target for most services.
Waiting for .NET 11 leaves you no testing buffer.
Pin the SDK with global.json, set the target framework in one place, and read the breaking changes.
Start with one small service, then move the rest.

This is a practical guide, not a full list of every change. Always check the official docs for your own stack.

The sample config is on GitHub:
https://github.com/ahmedshahjr/Articles/tree/main/should-you-migrate-to-dotnet-10

Direct link to the sample folder:
In the next post we will look at the new C# 14 field keyword and how it removes a lot of property boilerplate.

Which .NET version are your services running today, and what is the one thing blocking your move to .NET 10?

MIDDLEWARE BEST PRACTICES 💪

Ahmed Shah — Tue, 02 Sep 2025 17:17:53 +0000

MIDDLEWARE BEST PRACTICES 💪✅ Keep middleware focused (single responsibility)✅ Order matters - plan your pipeline✅ Use built-in before custom✅ Always call next() or terminate✅ Handle exceptions gracefully

Introducing Rejigs: A Developer-Friendly Regex Builder for .NET

Ahmed Shah — Mon, 14 Jul 2025 09:25:54 +0000

Regex is powerful — but let’s be honest, it’s also painful.
Too cryptic, too easy to break, and let’s not even talk about debugging them.

That’s why I use Rejigs — a NuGet package that lets you build, chain, and manage regular expressions using readable, fluent syntax.
Easy to use.

✨ Key Features:
✅ Fluent interface (.StartOfLine().Then("hello").Maybe("world").EndOfLine())
✅ Easy to read, build, and maintain regex patterns
✅ No more trial-and-error spaghetti strings

Available on => nuget.org/packages/Rejigs

=> Do you still write raw regex in your apps?
=> Would a tool like this simplify your workflow?

Drop your thoughts, ideas, or brutal regex horror stories in the comments!
Let’s make regex less scary — one pattern at a time.

dotnet #csharp #regex #NuGet #opensource #developerexperience #fluentapi

Add an .editorconfig file to your solution right from the start! 🛠️

Ahmed Shah — Sun, 20 Apr 2025 08:47:47 +0000

Whenever Starting a new project Add an .editorconfig file to your solution right from the start! 🛠️

Why?

An EditorConfig file ensures every developer on your team follows the same coding conventions—whether they use Visual Studio, VS Code, Rider, or another IDE. It’s like a rulebook for your codebase, eliminating debates over tabs vs. spaces, indentation, naming, or formatting.

Key Benefits for Your Team:

=> Consistency First: Enforce coding styles (e.g., indent size, line endings, charset) across all files and contributors.

=> Fewer Code Review Hassles: Reduce time spent arguing over formatting. Focus on logic and architecture instead!

=> IDE-Agnostic: Works seamlessly with most editors—no more "But my IDE auto-formatted it!" excuses.

=> Built-In .NET Core Support: .NET SDKs natively recognize .editorconfig, making it easy to align with compiler warnings or code analysis rules.

=> Version Control Friendly: Commit the file to your repo, and everyone stays in sync.

How to Add It in 2 Minutes:

In Visual Studio: Right-click your project → Add → New Item → Search for “.editorconfig” → Choose the template.

Manually: Create a .editorconfig file at the solution root and define your rules.

DotNetCore #CodingStandards #DeveloperTips #SoftwareEngineering #TechCommunity #CleanCode #DevOps

Let’s build cleaner, more maintainable codebases—one config file at a time! 🚀

Example Snippet:

🚀 Mastering Filters in ASP.NET Core

Ahmed Shah — Wed, 16 Oct 2024 04:04:06 +0000

Mastering Filters in ASP.NET Core.

If you're working with ASP.NET Core, you're likely already familiar with controllers and actions, but have you explored filters yet? Filters in ASP.NET Core are an incredibly powerful feature that allow you to add functionality before or after an action method is executed, making them perfect for cross-cutting concerns like logging, error handling, and authorization. 🔍

Authorization Filters
Purpose: Check if the user is authorized to access a resource.
Example: [Authorize] attribute.
Usage: Can be applied globally, to controllers, or to specific actions.

Resource Filters
Purpose: Run code before and after the execution of the rest of the pipeline. Often used for caching.
Example: Implementing IResourceFilter.
Usage: Executes after authorization but before model binding.

Action Filters
Purpose: Run code before and after an action method executes.
Example: [OnActionExecuting] and [OnActionExecuted] attributes.
Usage: Ideal for logging, validation, or modifying the action result.

Exception Filters
Purpose: Handle exceptions thrown by action methods or other filters.
Example: Implementing IExceptionFilter.
Usage: Great for global exception handling strategies, such as logging or custom error responses.

Result Filters
Purpose: Run code before and after the execution of action results.
Example: [OnResultExecuting] and [OnResultExecuted] attributes.
Usage: Useful for modifying the response, e.g., adding headers or changing the result.

Why are filters a game-changer?

Because they help you keep your code DRY (Don't Repeat Yourself) and maintainable! 🙌

If you're looking to simplify your ASP.NET Core development, it’s time to explore the power of filters!

🚀 Secure your .NET Apps with Visual Studio! 🚀

Ahmed Shah — Sun, 22 Sep 2024 06:30:00 +0000

As developers, ensuring the security of our applications is paramount. Did you know that Visual Studio has a feature to help you identify vulnerable packages in your projects?

By using the “Show only vulnerable packages” option in the NuGet Package Manager, you can quickly pinpoint and address any security issues in your dependencies.

This feature leverages data from the GitHub Advisory Database to alert you about known vulnerabilities, making it easier to keep your projects secure and up-to-date.

How to Use It:

Open your project in Visual Studio.

Navigate to the NuGet Package Manager.

Check the “Show only vulnerable packages” option.

Review the listed packages and update or replace them as needed.

Stay ahead of potential security threats and ensure your software is robust and reliable. Happy coding! 💻✨

VisualStudio #NuGet #CyberSecurity #DevSecOps #SoftwareDevelopment

🚀 TrueForAll in C# 🚀

Ahmed Shah — Tue, 17 Sep 2024 10:18:21 +0000

We often encounter scenarios where we need to check if all elements in a collection meet a specific condition.
That’s where TrueForAll comes in, offering a cleaner, more efficient way to handle these checks simplicity.

🚀 Unlock Your Business Potential with Keyed Services Implementation in .NET Core! 🚀

Ahmed Shah — Wed, 11 Sep 2024 09:31:31 +0000

Are you looking to optimize your application architecture and enhance scalability? Keyed Services in .NET Core might be the game-changer you need! 🔑💻

Keyed Services in .NET Core provide a robust way to manage dependencies and improve the service selection of your application. By leveraging this powerful feature, you can:

✨ Boost Scalability: Ensure your services can handle growing loads efficiently.
🔧 Enhance Flexibility: Tailor service implementations based on specific needs or contexts.
⚙️ Improve Maintainability: Simplify updates and management of complex service dependencies.

Define the Interface and Classes Where it needs to implemented

Inject in the Program.cs

Inject the Service in you specified Controller or Service

Notice in the constructor we are passing the key for the required service we want to use. we can move it to app settings and use it using the IOptions Pattern also.
This approach allows you to manage multiple implementations of a service and choose the appropriate one at runtime based on a key.

Let Run the Project using Outlook Service and See the Results.

we can see the message return from the Outlook Service.

Let Change the Key to Gmail Service and Hot Reload Our Project.

Now the Response changed to Outlook Service.

This Key can be changed using iOptions pattern. you can see my previous article how to use it. Link to the atricle
IOptions Pattern
Code For Current Article
Keyed Services GIthubLink
🔍 #DotNetCore #KeyedServices #SoftwareDevelopment #ApplicationArchitecture #Scalability #CrossPlatform #PerformanceOptimization #TechInnovation #Programming #DevCommunity #CodingBestPractices

Feel free to connect if you want to dive deeper into how Keyed Services can be implemented in your projects or if you need any guidance on .NET Core!

💬 Drop a comment or DM me to discuss!

TechTalk #ProgrammingTips #SoftwareEngineering #DotNetCoreDevelopment #CodeOptimization

🔍 𝗘𝘅𝗽𝗹𝗼𝗿𝗶𝗻𝗴 𝘁𝗵𝗲 𝗕𝗲𝗻𝗲𝗳𝗶𝘁𝘀 𝗼𝗳 𝗘𝗻𝘂𝗺𝗲𝗿𝗮𝘁𝗶𝗼𝗻𝘀 𝘄𝗶𝘁𝗵 𝗘𝘅𝗽𝗹𝗶𝗰𝗶𝘁 𝗩𝗮𝗹𝘂𝗲𝘀 𝗶𝗻 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴

Ahmed Shah — Sat, 10 Aug 2024 10:54:44 +0000

𝗻𝘂𝗺𝗲𝗿𝗮𝘁𝗶𝗼𝗻𝘀 are a powerful tool in many programming languages, allowing us to assign names to a set of related values. But why should we consider assigning explicit numbers to these values? Here are a few reasons:

𝗥𝗲𝗮𝗱𝗮𝗯𝗶𝗹𝗶𝘁𝘆 𝗮𝗻𝗱 𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴
Enums with numbers can improve code readability. When we assign explicit numbers to enums, it becomes easier to understand the significance of each value, especially when these numbers have a specific meaning attached to them

𝗦𝘁𝗮𝗯𝗶𝗹𝗶𝘁𝘆 𝗔𝗰𝗿𝗼𝘀𝘀 𝗗𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝗩𝗲𝗿𝘀𝗶𝗼𝗻𝘀
If your software undergoes multiple versions and the enum values are stored in a database, using numbers can ensure stability. Even if you add, remove, or reorder enum members, the underlying values in the database remain consistent

𝗜𝗻𝘁𝗲𝗿𝗼𝗽𝗲𝗿𝗮𝗯𝗶𝗹𝗶𝘁𝘆 𝘄𝗶𝘁𝗵 𝗢𝘁𝗵𝗲𝗿 𝗦𝘆𝘀𝘁𝗲𝗺𝘀
When working with external systems that rely on specific numeric values, using enums with numbers can simplify the integration process and reduce potential errors

𝗘𝗮𝘀𝗲 𝗼𝗳 𝗗𝗲𝗯𝘂𝗴𝗴𝗶𝗻𝗴
During debugging, it's often easier to spot an incorrect number than an incorrect string. This can make the debugging process more efficient

hashtag#Programming hashtag#CodingBestPractices hashtag#Enums hashtag#CodeReadability hashtag#SoftwareDevelopment hashtag#CodeMaintenance hashtag#CSharp hashtag#DeveloperCommunity

Improve Your C# Code with Pattern Matching! 🚀

Ahmed Shah — Sun, 28 Jul 2024 15:41:44 +0000

🛑 Avoid complex nested if-else statements
✅ Use pattern matching with switch expressions

Which approach do you prefer? Share your thoughts and let's discuss the benefits of using pattern matching in C#!

🚫 Stop the Madness!! Use Cancellation Tokens Effectively in .NET Core🚫

Ahmed Shah — Wed, 24 Jul 2024 03:59:41 +0000

Ever get that sinking feeling when your .NET Core app gets stuck in a long-running operation, leaving users frustrated and resources wasted?

As developers, we often encounter long-running tasks in our applications. Whether it's an API call, a file upload, or a complex calculation, these tasks can sometimes hang or take longer than expected. This is where the power of CancellationToken in .NET Core comes in.

What Are Cancellation Tokens?

A CancellationToken is a lightweight object in ASP.NET Core that facilitates cooperative cancellation between threads or components. When a CancellationTokenSource is canceled (usually due to user input or a timeout), all consumers of the associated cancellation token are notified.

Why Use Cancellation Token?

🔎 Enhanced User Experience
🔎 Resource Management
🔎 Async Operations
🔎 Graceful Termination

Integrating CancellationToken in your .NET Core applications is a small change that can have a big impact. It enhances performance, improves user experience, and helps in resource management. 🛠️

When to Use CancellationToken?

🔹 API Requests=> Cancel ongoing API calls if the user navigates away or the request takes too long.
🔹 Background Services=> Terminate background tasks gracefully during application shutdown or restarts.
🔹 Parallel Tasks=> Manage parallel operations efficiently, especially when one task's result might affect others.
This Example Below is not recommended For Production its just for learning Purposes.
What are your experiences with CancellationToken? Share your thoughts and let's discuss! 💬👇

DEV Community: Ahmed Shah

C# 14's field Keyword: Property Validation Without a Backing Field

The problem: a private field just to add one check

What is the field keyword?

Before and after

Two more everyday patterns

Trim and normalize input

Lazy loading

The rules you need to know

Gotcha 1: initializers don't call the setter

Gotcha 2: a member already named field

When to keep an explicit backing field

Key takeaways

ahmedshahjr / Articles

Should You Migrate to .NET 10 Today? An Honest LTS Decision Guide

The dates that matter

What "end of support" really means

The decision guide

Migrate now

Migrate soon (but start this week)

It's fine to wait

Why .NET 10 and not .NET 11?

Step-by-step migration

1. Install the SDK and pin it with global.json

2. Change the target framework in one place

3. Update the Microsoft packages

4. Read the breaking changes (really)

5. Update the Docker base images

6. Update the CI pipeline

7. Update the Azure runtime setting

8. Run the tests, then deploy one service first

Should a tool do this for me?

Key takeaways

MIDDLEWARE BEST PRACTICES 💪

Introducing Rejigs: A Developer-Friendly Regex Builder for .NET

dotnet #csharp #regex #NuGet #opensource #developerexperience #fluentapi

Add an .editorconfig file to your solution right from the start! 🛠️

DotNetCore #CodingStandards #DeveloperTips #SoftwareEngineering #TechCommunity #CleanCode #DevOps

🚀 Mastering Filters in ASP.NET Core

🚀 Secure your .NET Apps with Visual Studio! 🚀

Open your project in Visual Studio.

Navigate to the NuGet Package Manager.

Check the “Show only vulnerable packages” option.

Review the listed packages and update or replace them as needed.

Stay ahead of potential security threats and ensure your software is robust and reliable. Happy coding! 💻✨

VisualStudio #NuGet #CyberSecurity #DevSecOps #SoftwareDevelopment

🚀 TrueForAll in C# 🚀

🚀 Unlock Your Business Potential with Keyed Services Implementation in .NET Core! 🚀

Define the Interface and Classes Where it needs to implemented

Inject in the Program.cs

Inject the Service in you specified Controller or Service

TechTalk #ProgrammingTips #SoftwareEngineering #DotNetCoreDevelopment #CodeOptimization

🔍 𝗘𝘅𝗽𝗹𝗼𝗿𝗶𝗻𝗴 𝘁𝗵𝗲 𝗕𝗲𝗻𝗲𝗳𝗶𝘁𝘀 𝗼𝗳 𝗘𝗻𝘂𝗺𝗲𝗿𝗮𝘁𝗶𝗼𝗻𝘀 𝘄𝗶𝘁𝗵 𝗘𝘅𝗽𝗹𝗶𝗰𝗶𝘁 𝗩𝗮𝗹𝘂𝗲𝘀 𝗶𝗻 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴

Improve Your C# Code with Pattern Matching! 🚀

🚫 Stop the Madness!! Use Cancellation Tokens Effectively in .NET Core🚫

What is the `field` keyword?

Gotcha 2: a member already named `field`