Forem: Ahmed Shah

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! 💬👇

🚀 🚀 Working with hierarchical data in .Net Core using the hierarchyid data type.(.Net Core 8) 🚀 🚀

Ahmed Shah — Tue, 02 Jul 2024 16:48:55 +0000

🚀 HierarchyId Data Type

The hierarchyid data type was introduced with SQL Server 2008. It’s specifically designed to represent and manipulate hierarchical data.

Hierarchical data structures contain parent-child relationships, and hierarchyid provides an efficient way to store and query such data.

In the context of databases, both Azure SQL and SQL Server support this data type.

🚀 Querying Hierarchical Data

Once you’ve stored hierarchical data using hierarchyid, you can perform various queries:Finding Ancestors and Dependents: You can query for ancestors (parents) and dependents (children) of specific items.

💡 Depth-Based Queries

Retrieve all items at a certain depth within the hierarchy.

🚀 Benefits of Using HierarchyId

It simplifies querying hierarchical data, making it easier and faster.

The hierarchyid type is more aligned with .NET norms than SqlHierarchyId. It’s designed to work seamlessly with Entity Framework Core (EF Core).

hierarchyid is a valuable tool for managing hierarchical data in .NET Core applications. 🌟 If you have any specific questions or need further assistance, feel free to ask! 😊

Github Documentation => https://github.com/efcore/EFCore.SqlServer.HierarchyId

🔑 Keyed Services in .NET Core 8: The Death of the Factory Pattern? 🔑

Ahmed Shah — Tue, 07 May 2024 04:12:22 +0000

In the world of .NET Core 8, we're always looking for ways to write cleaner, more maintainable code. One of the most significant recent developments in this area is the introduction of "Keyed Services" 🎉.

Keyed Services allow us to register multiple implementations of an interface with a unique key 🔑. We can then retrieve the specific implementation we need at runtime using this key. This is a significant improvement over the traditional Factory Pattern, where we had to manually control the creation of our objects 🏭.

With this approach, we no longer need to create complex factories or use service locators. Instead, we can rely on the built-in dependency injection container to handle this for us 🧰.

Does this mean the Factory Pattern is dead 💀? Not necessarily. There are still scenarios where the Factory Pattern might be the right choice. However, Keyed Services provide a powerful alternative that can simplify our code and make it more maintainable 🚀.

What are your thoughts on this? Have you used Keyed Services in your projects?