# Poorna Soysa

> Helping You to Reach New Heights as a .NET Engineer


## Posts

- [EF Core Read Query Performance – Optimization Techniques for .NET](https://poornasoysa.tech/ef-core-read-query-performance/): EF Core's defaults are built for convenience, not speed — and that gap shows up fast once your data grows. This guide walks through 10 practical techniques to boost EF Core read query performance in .NET, from indexing and AsNoTracking to pagination, split queries, and caching, with real code examples for every skill level.
- [LLM vs AI Agent – What's the Real Difference (And Why It Matters)](https://poornasoysa.tech/llm-vs-ai-agent/): LLMs and AI agents get used interchangeably, but they're not the same thing. This guide breaks down what each one actually does, how they work together, and how to decide which one your project really needs.
- [C# 15 Union Types Explained Simply – A Better Way to Handle Multiple Return Types](https://poornasoysa.tech/csharp-15-union-types-explained/): C# 15 introduces Union Types — a simple and type-safe way to handle multiple return types. Learn how it works and how to try it with .NET 11 Preview 2.
- [Rate Limiting Middleware in ASP.NET Core – Built-In, Practical, and Production-Ready](https://poornasoysa.tech/rate-limiting-middleware-aspnet-core/): ASP.NET Core 7 introduced built-in rate limiting middleware. This guide covers everything  from basic setup to advanced production patterns.
- [Data Validation in .NET 10 Minimal APIs – Built-In, Clean, and No Extra Libraries](https://poornasoysa.tech/data-validation-dotnet-10-minimal-apis/): .NET 10 introduces built-in data validation for Minimal APIs—no need for external libraries. This guide walks through Data Annotations, custom validation, and automatic error handling with real-world examples.
- [Complex Types in EF Core: Cleaner Domain Models and Reusable Value Objects](https://poornasoysa.tech/complex-types-in-ef-core/): Complex Types in EF Core help create cleaner domain models by grouping related values like Address or Money without separate tables. 
- [HybridCache in ASP.NET Core – A Better Way to Handle L1 & L2 Caching](https://poornasoysa.tech/hybridcache-aspnet-core-caching/): HybridCache in ASP.NET Core combines in-memory and distributed caching into a single API, improving performance and scalability with minimal effort.
- [Implementing Soft Delete in EF Core: A Practical Guide for Safer Data Management](https://poornasoysa.tech/implement-soft-delete-ef-core/): Learn how to implement soft delete in EF Core, global query filters, interceptors, and indexing. This guide also covers best practices, performance tips, and when to choose soft delete over hard delete.
- [How to Use EF Core Interceptors for Clean and Scalable Data Access](https://poornasoysa.tech/ef-core-interceptors/): Learn how to use EF Core Interceptors to handle auditing, logging, and cross-cutting concerns in a clean and scalable way, with practical examples and best practices.
- [Generate Fake Data in C# Using Bogus](https://poornasoysa.tech/generate-fake-data-csharp-bogus/): Learn how to generate realistic fake data in C# using Bogus. Includes object generation, custom rules, seeding, localization.
- [ExecuteUpdate and ExecuteDelete in EF Core – Faster Bulk Operations Without Loading Entities](https://poornasoysa.tech/bulk-update-delete-ef-core/): ExecuteUpdate and ExecuteDelete in EF Core allow performing bulk updates and deletes directly in the database without loading entities.
- [The New Visual Studio .slnx Solution File Format](https://poornasoysa.tech/visual-studio-slnx-solution-file-format/): Visual Studio introduces the new .slnx solution file format, a cleaner and more readable replacement for .sln. Built for modern .NET workflows, .slnx reduces merge conflicts, improves source control collaboration.
- [Dapper Plus Options Explained: Everything You Can Customize](https://poornasoysa.tech/dapper-plus-options-explained/): Dapper Plus offers far more than fast bulk operations. This guide explains every major option — from mapping and keys to batching, audit, and merge behavior — with examples.
- [LeftJoin and RightJoin Operators in EF Core 10](https://poornasoysa.tech/leftjoin-and-rightjoin-operators-in-ef-core-10/): Article Sponsors EF Core too slow? Insert data up to 14x faster and cut save time by 94%. Boost performance with extension methods fully integrated into EF Core — Bulk Insert, Update, Delete, and Merge. Join 5,000+ developers who’ve trusted our library since 2014. 👉 Try it now — and feel the difference Outer joins play a major role in relational data access, yet writing them in LINQ has never been as intuitive as writing SQL. Developers were required to combine GroupJoin, SelectMany, and DefaultIfEmpty() to mimic SQL’s LEFT JOIN behavior. Although the output was correct, the LINQ expressions didn’t […]
- [Entity Framework Extensions Options Explained: Everything You Can Customize](https://poornasoysa.tech/entity-framework-extensions-bulkinsert-options-explained/): Explore every customizable BulkInsert option in Entity Framework Extensions, including behavior settings, custom keys, batch tuning, IncludeGraph, performance options, and provider-specific features.
- [What’s New in C# 14](https://poornasoysa.tech/csharp-14-new-features-guide/): C# 14 introduces powerful improvements like extension members, the new field keyword, cleaner lambdas, null-conditional assignment, and performance-focused features that simplify everyday coding and make .NET 10 apps faster and more expressive.
- [Top 7 Options You Should Try in EF Core Bulk Operations](https://poornasoysa.tech/ef-core-bulk-operations-options/): Discover the most powerful EF Core bulk operation options—from IncludeGraph to batch tuning, temporary tables, audit logs, and events. A must-read for EF Core 10 developers.
- [Data Seeding in EF Core 9 - Everything You Need to Know](https://poornasoysa.tech/data-seeding-in-ef-core-9/): EF Core 9 introduces flexible data seeding with UseSeeding() and UseAsyncSeeding(). Learn how to use these new APIs, compare them with HasData(), and follow best practices for initializing your database.
- [Introduction to CRUD Operations with Dapper and Dapper Plus](https://poornasoysa.tech/dapper-plus-for-dotnet/): Discover how to combine Dapper’s simplicity with Dapper Plus’s speed to perform high-performance CRUD operations in .NET. See how bulk methods and benchmarks prove up to 24× faster inserts and 15× faster updates.
- [How to Build AI Agents Workflow Using Microsoft Agent Framework](https://poornasoysa.tech/build-ai-agents-workflow-dotnet-microsoft-agent-framework/): Building intelligent workflows with multiple AI components can quickly become complex, especially when managing how they interact and share data. That’s where the Microsoft Agent Framework comes in.
- [EF Core Tricks for Bulk Reading Large Data Sets](https://poornasoysa.tech/ef-core-bulk-reading-wherebulkcontains-bulkread/): Handling large data sets in EF Core can quickly become a performance challenge, especially when using the standard Where + Contains approach. That’s where Entity Framework Extensions comes in. 
- [EF Core Pagination: Offset and Keyset (Cursor-Based) Explained](https://poornasoysa.tech/ef-core-pagination-offset-and-keyset-methods/): Efficient pagination is key when working with large datasets in EF Core. In this guide, we explore two main strategies Offset Pagination and Keyset (Cursor-Based) Pagination, along with advanced techniques like indexing for performance.
- [The Complete Guide to Bulk Operations with Entity Framework Extensions](https://poornasoysa.tech/ef-core-bulk-operations/): EF Core slows down with large datasets. This guide explains how Entity Framework Extensions improves EF Core bulk operations with BulkInsert, BulkUpdate, BulkDelete, BulkMerge, and BulkSynchronize. 
- [Ollama with .NET - Run AI Models Locally Using C# and Docker](https://poornasoysa.tech/ollama-with-dotnet-local-ai-csharp-docker/): Discover how to run AI models locally with Ollama and .NET. This guide covers setup, pulling models, C# integration with OllamaSharp, and Docker usage.
- [New LINQ Methods in .NET 9: Index, CountBy, and AggregateBy](https://poornasoysa.tech/dotnet-9-new-linq-methods/): .NET 9 introduces powerful new LINQ methods — Index, CountBy, and AggregateBy. This guide explains each method with before-and-after examples, showing how they reduce boilerplate and make queries more readable.
- [What’s New in C# 13 - Explore the Latest Features](https://poornasoysa.tech/whats-new-in-csharp-13/): C# 13, released with .NET 9, introduces powerful new language features that make coding cleaner, safer, and more flexible. From params collections and lock object extensions to partial properties, and expanded ref struct support.
- [Global Query Filters in EF Core - The Complete Guide (with .NET 10 Updates)](https://poornasoysa.tech/global-query-filters-in-ef-core/): Article Sponsors EF Core too slow? Insert data up to 14x faster and cut save time by 94%. Boost performance with extension methods fully integrated into EF Core — Bulk Insert, Update, Delete, and Merge. Join 5,000+ developers who’ve trusted our library since 2014. 👉 Try it now — and feel the difference When building applications with Entity Framework Core (EF Core), it’s common to find yourself writing the same filtering conditions in multiple queries. Maybe you’re hiding soft-deleted records, limiting results to a specific tenant, or showing only data that a certain role is allowed to see. For beginners, […]
- [Cache-Aside Pattern in ASP.NET Core – Improve Performance the Smart Way](https://poornasoysa.tech/cache-aside-pattern-in-aspnet-core/): Cache-Aside Pattern in ASP.NET Core is a proven approach to improve performance and scalability, especially when the same data is queried frequently from the database.
- [Fluent Builder Pattern in C# – Build Complex Objects Step-by-Step](https://poornasoysa.tech/fluent-builder-pattern-csharp/): In real-world applications, building objects with many optional parameters can become messy fast. You either end up with multiple constructors or an object initializer that’s hard to read and even harder to maintain. hat’s exactly where the Builder Pattern comes in. And when done right, using a fluent API style, it becomes not just cleaner — but a joy to work with. In this article, we’ll explore the Fluent Builder Pattern in C#, using a practical and easy-to-understand example: building a report. The Problem: Object Construction Chaos Let’s say you’re building a reporting module in your application. You want to […]
- [How to Create Middleware in ASP.NET Core – Request Delegate, Convention-Based, and Factory-Based Approaches](https://poornasoysa.tech/how-to-create-middleware-in-asp-net-core/): Learn how to build custom middleware in ASP.NET Core using request delegates, class-based logic, and IMiddleware—plus when to use each with real-world examples.
- [Understanding Middleware in ASP.NET Core — The Core Building Block of the Request Pipeline](https://poornasoysa.tech/understanding-middleware-in-aspnet-core/): In ASP.NET Core, middleware is more than just a feature — it’s the foundation of how every request and response flows through your application. If you’re building web APIs or full-stack applications with ASP.NET Core, understanding middleware is essential to writing clean, efficient, and extensible code. In this article, we’ll break down what middleware is, how the request pipeline works, and why middleware plays such a crucial role in ASP.NET Core. What is Middleware in ASP.NET Core? Middleware is software that’s assembled into an application pipeline to handle requests and responses. In ASP.NET Core, every incoming HTTP request passes through […]
- [dotnet run app.cs – Run C# Without a Project in .NET 10](https://poornasoysa.tech/dotnet-run-app-cs-run-c-without-project-net-10/): Learn how the new dotnet run app.cs command in .NET 10 lets you execute C# code without creating a full project. Perfect for quick testing and learning.
- [Understanding Dependency Injection in ASP.NET Core - Lifetimes, Setup, and Best Practices](https://poornasoysa.tech/dependency-injection-aspnet-core/): A complete guide to Dependency Injection in ASP.NET Core. Covers how it works, service lifetimes, how to register services in Program.cs, and how to use constructor injection effectively—along with best practices for maintainable code.
- [Options Pattern in ASP.NET Core Made Simple - Configuration the Right Way](https://poornasoysa.tech/options-pattern-in-asp-net-core-made-simple-configuration-the-right-way/): Learn how to use the Options Pattern in ASP.NET Core to bind configuration settings the right way. Includes IOptions, validation, and real-world setup tips.

## Pages

- [Privacy Policy](https://poornasoysa.tech/privacy-policy/): Effective Date: April 10, 2026 Welcome to https://poornasoysa.tech/. Your privacy is important, and this Privacy Policy explains how information is collected, used, and protected when visiting this website. 1. Information We Collect Personal Information Personal information may be collected when voluntarily provided, such as: Non-Personal Information We may automatically collect certain information, including: 2. How We Use Your Information The collected information may be used to: 3. Cookies This website uses cookies to: Users can disable cookies through browser settings. 4. Third-Party Services This website may use third-party services (such as analytics or email services) to improve functionality and user […]
- [About](https://poornasoysa.tech/about/): Hello! I’m Poorna Soysa — a software architect and content creator with over 15 years experience in the field. My focus is on helping fellow developers build high-performance, scalable applications through proven .NET practices. At the end of the day, my goal is simple: to help developers build better software and grow as professionals.
- [Home](https://poornasoysa.tech/): Push Your .NET Skills Beyond Boundaries Subscribe to the .NET Weekly Tips by Poorna for practical tips, best practices, and source code every week Latest articles The .NET Weekly Tips By Poorna youtube Videos Watch and Learn .NET with Poorna Connect with Me I share valuable .NET and software engineering insights on social media. Let’s connect and collaborate!
- [Articles](https://poornasoysa.tech/articles/): Stay updated with the newest .NET tutorials and coding articles. Learn C#, explore ASP.NET Core, EF Core, and improve your development skills with step-by-step guides.

## Optional

- [Agent (MCP protocol)](websites-agents.hostinger.com/poornasoysa.tech/mcp)

[comment]: # (Generated by Hostinger Tools Plugin)