DEV Community: Mohamed Ashmawy

🚀 Introducing AutoMediate: A Drop-In Mediator for .NET

Mohamed Ashmawy — Sat, 16 Aug 2025 22:25:14 +0000

If you’ve ever worked with the Mediator pattern in .NET, you’ve probably come across MediatR.
It’s a great library, but sometimes it adds more configuration and boilerplate than you’d like.

That’s why I built AutoMediate 🎉 — a lightweight, convention-based mediator library designed as a drop-in replacement for MediatR — but with less friction.

✨ Why AutoMediate?

🔌 Zero configuration — handlers are automatically wired up.

🪶 Lightweight & clean — keep your code simple.

⚡ Fast — minimal overhead.

🤝 Familiar pattern — same mediator style you know.

💯 Free & Open Source (unlike MediatR).

📦 Get Started

AutoMediate is available today:

GitHub: https://github.com/mashmawy/AutoMediate

NuGet: https://www.nuget.org/packages/AutoMediate

Example usage
public record Ping(string Message) : IRequest<string>;

public class PingHandler : IRequestHandler<Ping, string>
{
    public Task<string> Handle(Ping request, CancellationToken ct) 
        => Task.FromResult($"Pong: {request.Message}");
}

No configuration needed — AutoMediate wires it up automatically.

🙌 Feedback Welcome

I’d love for you to try it out, share your thoughts, and maybe even contribute.

dotnet #csharp #opensource #nuget #architecture

Rule Engines

Mohamed Ashmawy — Mon, 23 Sep 2024 21:54:13 +0000

Complex business logic may be effectively managed and streamlined with the help of rule engines. Rules offer a versatile and easily maintainable approach that can adapt to your business's changing demands by separating themselves from the application code.

Rule Engines: Why Use Them?

Flexibility: You can easily add, delete, or amend rules without having to change the application code.
Maintainability: It is easier to handle centralized business logic.
Reusability: Rules are transferable to other applications or domains.
Performance: Large rulebases and datasets are handled by optimized engines with ease.

How to Put a Rule Engine Into Practice:

Determine Business Rules: Examine procedures and record precise decision-making points and limitations.
Select a Rule Engine: Consider functionality, scalability, and integration requirements while evaluating engines.
Describe the language used in the rule: You may design your own rule language or use one of the common ones, such as Drools or Jess.
Establish the Rulebase: Business regulations should be translated into the selected language and arranged for convenience of management.
Integrate: Incorporate the rule engine into your program to guarantee efficient rule changes and execution.
evaluate and Validate: Apply real-world scenarios to thoroughly evaluate the engine, making necessary refinements.

💡 Want a real-world example? Check out how you can create a rule engine using my expression evaluator library NeonBlue.Expressions at https://github.com/mashmawy/NeonBlue.Expressions/tree/master/NeonBlue.Expressions.Examples. It’s designed to help you efficiently handle dynamic rules and calculations in your applications!

Best Practices:

Make regulations clear and concise.
Make consistent and lucid use of language.
For efficiency, make use of inheritance and rule chaining.
Keep an eye on and improve the rulebase constantly.

Businesses may use rule engines to create flexible, maintainable, and high-performing applications by following these guidelines.

🚀 New Version of NeonBlue.Expressions Released!

Mohamed Ashmawy — Sat, 21 Sep 2024 20:16:23 +0000

I’m excited to announce a new version of NeonBlue.Expressions, featuring key enhancements based on some incredible feedback. 🎉

🔧 What’s New:

Power Operator (^): You can now perform exponentiation directly in your expressions.

Support for Null, True, False: Added native handling for null, true, and false keywords, enhancing logical expression support.

Mathematical Constants: Added pi and tau keywords for more precise mathematical calculations.

Additional Improvements:

Performance Boost: Enhanced expression evaluation for faster execution.

Cleaner Codebase: Applied feedback to make the code more efficient and maintainable.

Bug Fixes: Improved overall stability and resolved minor issues.

Check out the latest version on GitHub and let me know what you think! Your feedback is invaluable as I continue to refine and expand the library.

💻 GitHub Repository: https://github.com/mashmawy/NeonBlue.Expressions

📦 NuGet Package: https://www.nuget.org/packages/NeonBlue.Expressions/0.1.3

Thank you to everyone contributing to making this project better! 🌟

CSharp #DotNet #OpenSource #Developers #CodeEfficiency #GitHub #ExpressionLibrary

🚀 Introducing NeonBlue.Expressions – A C# Expression Evaluation Library for Developers!

Mohamed Ashmawy — Thu, 19 Sep 2024 12:00:12 +0000

🚀 Introducing NeonBlue.Expressions – A C# Expression Evaluation Library for Developers!

Hi, #CSharp developers! 🎉

I’m excited to announce the early-stage release of NeonBlue.Expressions, a library designed to make expression evaluation in .NET faster and more efficient.

🔧 Key Features (so far):

-Direct Interpretation: NeonBlue.Expressions’s interpreter directly executes expressions, minimizing computational overhead.

-Efficient Aggregate Functions: Optimized aggregation techniques significantly improve performance when working with large datasets.

-Lightweight and Fast: Designed for performance, NeonBlue.Expressions is optimized for efficient expression evaluation.

-.NET 8 Compatibility: Built on the latest .NET framework, ensuring compatibility with modern features.

-Ease of Use: A straightforward API simplifies integration into you .NET applications.

This is just the beginning—more features are on the way! I’m actively working on updates and would love for you to try it out, share feedback, and contribute.

💻 GitHub Repository: https://github.com/mashmawy/NeonBlue.Expressions

Let’s grow this project together—your feedback and contributions are invaluable! 🚀