We were just getting used to .NET 10. Now, Microsoft has already released .NET 11 Preview 1. This release is significant, and the emphasis is clearly on improving performance. Microsoft for Developers

Here are the key points that caught my attention from the release notes:

1. Native AI-friendly numeric support (BFloat16):
   .NET 11 Preview 1 introduces support for BFloat16. GitHub
   Why does this matter? BFloat16 is popular in AI training and inference because it lowers memory usage and increases speed while maintaining acceptable precision.

2. Compression leveled up (Zstandard):
   There is now native support for Zstandard in System.IO.Compression, including types like ZstandardStream and related options. heise online
   Why does this matter? Zstandard strikes a great balance between compression ratio and speed, which effectively reduces network traffic and cloud storage costs.

3. Runtime async improvements (real work under the hood):
   This preview includes significant updates for async execution and diagnostics at runtime.
   Microsoft for Developers
   Why does this matter? Async paths can operate more efficiently with less overhead, and debugging is getting easier, especially for deep async call chains and handling exceptions.

4. Smarter JIT for loops (Induction Variable analysis):
   The JIT now performs deeper analysis of loops, allowing for more automatic optimizations.
   Microsoft for Developers
   Why does this matter? This can speed up code that involves heavy loops and computations without needing you to make changes—especially useful in numeric and processing tasks.

5. The CLI became interactive (better daily dev experience):
   dotnet run now supports selecting target frameworks and devices interactively for multi-target projects, with MAUI being a prime example. GitHub
   Why does this matter? It speeds up your workflow and cuts down on the flags you must remember and type each time.

6. System.Net.Mime.MediaTypeMap (finally!):
   There is now an official API to map file extensions to MIME types and back, for example, .png to image/png. Microsoft Learn
   Why does this matter? For years, we either created our own solutions or relied on third-party libraries for something that should have been standard. Now it’s built-in.

7. EF Core improvements and faster migrations workflow:
   The EF Core tools and JSON mapping are continuing to improve, with enhancements to migration workflows and better JSON support for complex scenarios. Microsoft for Developers

8. MAUI got faster (XAML source generation):
   XAML source generation is now the default in MAUI for .NET 11. Microsoft for Developers
   Why does this matter? It leads to faster builds, smoother debugging, and better runtime performance as more tasks move from runtime to compile time.

If you want to try it:
.NET 11 Preview 1 is available now, and using preview tooling is recommended. Microsoft for Developers

In summary, this update demonstrates that .NET is not "just for the web" anymore. It is increasingly evolving into a platform suited for high-performance workloads and AI-ready situations.

But JSON wasn’t designed to be token-efficient for LLMs.

TOON (Token-Oriented Object Notation) is a format designed for communicating structured data to LLMs with less token overhead than JSON—especially for arrays of similar objects (rows in a table).

This article focuses on:

• why JSON wastes tokens in prompts
• what TOON changes
• how to compare TOON vs JSON fairly
• how to apply TOON in ABP without changing your public APIs

Why JSON is inefficient for LLM prompts

JSON is excellent for APIs, but expensive for prompts because it includes many tokens that add structure rather than meaning:

1) Repeated property names

If you send a list of 200 records, each record repeats keys like "id", "name", "creationTime", "status".

2) Structural punctuation

Characters like { } [ ] , : " are necessary for parsers, but they add tokens that don’t help the model understand your data.

3) Nested objects amplify overhead

The more nesting you have, the more braces and repeated keys you pay for.

This is why “just send the DTO as JSON to the LLM” can unexpectedly inflate prompt token count.

What TOON changes

TOON represents the same JSON data model (objects, arrays, primitives) but optimizes the way structured data is written so that prompts often contain less repeated text and less structural clutter.

The most useful shape (and the one you’ll feel immediately in real products) is:

Arrays of similar objects → tabular representation

Instead of repeating keys in every row, TOON can define the “columns” once and then list rows.

Practical comparison: JSON vs TOON (same data)

Let’s use a realistic “records list” shape (the kind you commonly pass to LLMs): timestamps + user + text.

JSON (typical)

[
  {
    "creationTime": "2026-01-01T10:15:00Z",
    "userName": "admin",
    "text": "On mobile the Post button disables randomly..."
  },
  {
    "creationTime": "2026-01-01T10:20:00Z",
    "userName": "hamza",
    "text": "Please add pagination for large comment lists..."
  }
]

TOON (conceptual tabular array)

Exact syntax depends on the encoder you use; the important part is the structure: define columns once, then provide rows.

# records (tabular)
[creationTime userName text]
[
  ["2026-01-01T10:15:00Z" "admin" "On mobile the Post button disables randomly..."]
  ["2026-01-01T10:20:00Z" "hamza" "Please add pagination for large comment lists..."]
]

Why TOON is often more token-efficient here

• JSON repeats "creationTime", "userName", "text" in every object
• TOON pays those field names once, then streams rows
• For larger lists (50–500 rows), repeated-key overhead becomes significant

Where TOON helps most (and where it doesn’t)

TOON usually helps when

• You send lists of records (audit logs, tickets, comments, search results, transactions)
• You return structured results to the model (tool output / function output)
• You frequently hit prompt size limits or cost issues

JSON is still fine when

• Payloads are tiny (1–3 objects)
• Structures are deeply nested and irregular
• Human readability of raw prompt payloads is more important than tokens

How to compare TOON vs JSON fairly

To avoid misleading comparisons, keep these rules:

1) Compare against minified JSON

Pretty JSON is larger than the JSON you’d actually send. Always compare TOON against minified JSON.

2) Same data, same ordering

Ensure records are identical, same order, same quoting rules, same escaping.

3) Use the same tokenizer as your target model

Token counts differ by model/tokenizer. Use the tokenizer that matches your provider/model whenever possible.

4) Measure at multiple sizes

The win usually grows with the number of rows:

• 10 rows
• 50 rows
• 100 rows
• 200 rows

A simple “real numbers” section template (fill after measuring)

Once you’ve measured your real payloads, include a short results section:

Token comparison results

• Dataset: {N} records
• Fields: {field list}
• JSON (minified) tokens: {JSON_TOKENS}
• TOON tokens: {TOON_TOKENS}
• Reduction: {PERCENT}%

How TOON fits into ABP apps

ABP applications already have clean separation between:

• API contracts (DTOs)
• application services
• integrations

That makes it easy to adopt TOON without changing your API:

Recommended rule

• Keep your ABP HTTP APIs as JSON

• Use TOON only in the AI boundary:

  • prompt context formatting
  • tool output formatting before sending back to the model

Clean layering idea

Create a small abstraction like:

• IPromptContextFormatter or IToonFormatter

So the rest of your application stays provider-agnostic and format-agnostic.

Migration strategy (safe adoption)

If you’re introducing TOON into an existing AI feature:

1. Add TOON formatting behind an interface

2. Keep a fallback to minified JSON while you validate correctness

3. Add a feature flag:

   • UseToonForAiContext = true/false

4. Measure token & latency changes

This lets you roll TOON in gradually and safely.

Conclusion

JSON is a great API format, but for LLM prompts it often carries unnecessary token overhead—especially for large lists of similar objects.

TOON is a practical alternative for the AI boundary: it preserves structure while often reducing repeated-key and punctuation overhead. The best way to adopt it in ABP is not to replace JSON everywhere, but to format AI context as TOON while keeping your public APIs unchanged.

What’s official from Microsoft

• AI built into the IDE
  AI is now part of the workflow. It understands your solution, helps with paste-and-fix, suggests tests and documentation, and shows performance or security insights before you commit.
  Read the announcement

• Insiders Channel
  The new Insiders Channel replaces Preview, giving early access to features with frequent updates.

• Performance improvements
  Faster solution load, quicker builds and debugging, and better first launch. Optimized for both x64 and Arm64.

• UI refresh
  Fluent UI design, updated icons, cleaner spacing, and a modernized settings experience.

• Latest .NET and C# support
  Built-in support for .NET 10 and C# 14.

• Side-by-side install
  Install VS 2026 alongside VS 2022 and migrate your extensions and settings.
  Download Visual Studio 2026 Insiders

• Editor and productivity updates
  A more informative bottom margin (line/column numbers, character count, encoding), Copilot context actions, a BenchmarkDotNet template, and Hot Reload improvements for Razor.
  See the release notes
  

What I hope to see next

These aren’t confirmed by Microsoft, but they’re on my wishlist as an ABP.io developer:

• AI that understands modular ABP solutions and can suggest best practices.
• Easier setup for multi-tenant projects with less boilerplate.
• Built-in helpers for Azure CI/CD pipelines.
• Lower memory usage on very large solutions.

Visual Studio 2026 vs Rider vs VS Code

• VS Code — great for smaller projects and quick edits, but still just an editor with extensions.
• JetBrains Rider — often praised for responsiveness and strong refactoring/navigation tools, especially on large codebases.
• Visual Studio 2026 — strongest integration with Microsoft’s ecosystem, support for new .NET/C# releases immediately, and deeper AI and performance improvements.

Why this matters for ABP.io projects

• ABP.io is all about modular monoliths and multi-tenancy. Faster solution load and better Hot Reload directly help in these setups.
• ABP.io provides identity, auditing, background jobs, and modules out of the box. If Visual Studio’s AI continues to improve, it could save a lot of time on scaffolding and boilerplate.

Conclusion

Visual Studio 2026 Insiders already brings:

• AI integrated into the IDE
• Performance gains for large solutions
• A modern UI refresh
• Support for .NET 10 and C# 14
• Productivity updates like Hot Reload and Benchmarking

For me, the big question is how well it will handle large ABP.io solutions and whether the AI tools actually reduce development time. If it delivers, it could easily become my main IDE.

Download Visual Studio 2026 Insiders

The good news is that Visual Studio provides powerful tools that allow you to step directly into NuGet packages, observe their internal workings, and gain invaluable insights for troubleshooting and learning.

Why Debug NuGet Packages?

Before diving into the how-to, let's quickly understand why this capability matters:

• Troubleshooting: Identify the root cause of issues that originate within package code
• Learning: Understand how ABP Framework implements various features
• Better Integration: See how your code should interact with ABP modules
• Customization: Make informed decisions when overriding or extending ABP functionality

Prerequisites

• Visual Studio 2019 or later
• An ABP Framework project with NuGet packages you want to debug

Setting Up Visual Studio for NuGet Package Debugging

Let's walk through the process step by step:

1. Disable "Just My Code"

This is the first critical step that tells Visual Studio to allow debugging of external code.

1. Open Visual Studio
2. Navigate to Tools → Options
3. In the Options dialog, select Debugging → General
4. Uncheck the option labeled "Enable Just My Code"

2. Configure Symbol Loading

Symbols (PDB files) provide the mapping between compiled code and source code, making debugging possible.

1. In the Options dialog, go to Debugging → Symbols
2. Check "Microsoft Symbol Servers" to download symbols from Microsoft's servers
3. Check "NuGet.org Symbol Server" if available (or add https://symbols.nuget.org/download/symbols manually)
4. Set a cache location for symbol files (the default is typically in your AppData folder)

3. Enable Source Link Support

Source Link is a technology that helps the debugger locate and download source code from repositories.

1. In the same Options dialog, ensure you're in Debugging → General
2. Check "Enable Source Link support"
3. For additional control, you can also check "Enable Source Server support"

Understanding Source Link

Source Link is a vital technology that bridges the gap between compiled code and source code repositories. Here's what you need to know:

• What is Source Link? It's a technology that embeds source control metadata into NuGet packages and assemblies, allowing debuggers to download the exact source code used to build those binaries.

• How it Works: When you step into a method from a NuGet package, Source Link provides the debugger with information about where to find the corresponding source file in the original repository.

• ABP Framework Compatibility: Most ABP.IO packages already support Source Link, making it possible to debug directly into their source code.

Debugging in Action: A Real-World Example

Let's say you're overriding the IdentityUserAppService in your application, and you want to understand how the base implementation works:

1. First, place a breakpoint on your call to the base method:

public override async Task<IdentityUserDto> CreateAsync(IdentityUserCreateDto input)
{
    // Place breakpoint here
    var result = await base.CreateAsync(input);
    // Your custom code
    return result;
}

2. Start debugging your application and navigate to the part that triggers this code
3. When execution hits your breakpoint, press F11 (Step Into) to step into the base class implementation
4. Visual Studio will:
   • Download necessary symbols (if not already cached)
   • Use Source Link to fetch the original source code
   • Open the source file and position the cursor at the method you're stepping into

5. You can now debug through the ABP Framework code just like your own code:
   • Inspect variables
   • See the execution flow
   • Set additional breakpoints
   • Use all standard debugging features

Debugging ABP Commercial Modules

Commercial ABP modules (e.g., Volo.Saas, Volo.Payment, Volo.FormManagement) are not open-source and are distributed as obfuscated and encrypted DLLs. Consequently, Source Link does not support these modules, and you cannot debug them directly unless you have access to their source code .

What About ABP Commercial Packages?

Commercial packages like Volo.Saas, Volo.Payment, and Volo.FormManagement:

• Are not Source Link enabled
• Contain obfuscated and protected DLLs
• Cannot be debugged unless you have direct source code access

✅ If You Have an ABP Commercial License: You can access the source code directly:

1. Follow the official guide
2. Reference the source modules instead of NuGet packages
3. You can then debug them like any other part of your app

⚠️ Do not attempt to decompile or reverse-engineer ABP Commercial DLLs — it violates licensing agreements.

Troubleshooting Common Issues

Symbols Not Loading

If you're unable to load symbols:

1. Verify your symbol server settings are correct
2. Check your internet connection (symbols need to be downloaded)
3. Try clearing your symbol cache:
   • Go to Tools → Options → Debugging → Symbols
   • Click "Clear All Symbol Cache Directories"
4. Ensure the package actually includes symbols (not all do)

Source Code Not Found

If symbols load but source code doesn't:

1. Verify that "Enable Source Link support" is checked
2. Check if the repository containing the source code is public
3. For private repositories, you may need to configure authentication
4. Try enabling verbose Source Link diagnostics to see what's happening

Performance Considerations

Debugging with symbols and Source Link can impact performance:

1. Loading symbols and source files takes time, especially on first use
2. Consider using the "Load only specified modules" option to load symbols selectively
3. Once you're done debugging packages, re-enable "Just My Code" for normal debugging

Best Practices for ABP Development

When to Use NuGet Package Debugging

• During troubleshooting of unexpected behavior
• When learning how to properly extend ABP functionality
• Before implementing complex customizations

When to Avoid It

• For day-to-day development when you don't need to see inside packages
• When performance is a concern
• When you're already familiar with the internals

Conclusion

Stepping into NuGet packages is an invaluable skill for ABP developers. Whether you're troubleshooting complex issues, understanding how to properly extend the framework, or simply learning how ABP works under the hood, this technique provides insights that would otherwise be difficult to obtain.

Remember to toggle these settings only when needed, as they can impact your debugging performance. Once you're done exploring package internals, consider re-enabling "Just My Code" for your regular development workflow.

By mastering this technique, you'll be better equipped to work with ABP Framework effectively, troubleshoot issues faster, and create better integrations with the ABP ecosystem.

Additional Resources

• Official Visual Studio Debugging Documentation
• Understanding Debugging Symbols and Source Link
• ABP Framework Documentation
• Debugging ABP Framework Internals

This guide walks you through setting up DigitalOcean Spaces as your blob storage provider in an ABP application.

Step 1: Install the Required Blob Storage Packages

Before setting up DigitalOcean Spaces, make sure you have the core Blob Storing package installed:

abp add-package Volo.Abp.BlobStoring

Then, install the AWS Blob Storage Provider to enable S3-compatible storage:

abp add-package Volo.Abp.BlobStoring.Aws

Step 2: Configure DigitalOcean Spaces

Modify your module configuration file (YourModule.cs) and include the AWS provider settings:

// required DependsOn
[DependsOn(
    typeof(AbpBlobStoringModule),
    typeof(AbpBlobStoringAwsModule)
)]
public class YourModule : AbpModule
{
    public override void ConfigureServices(ServiceConfigurationContext context)
    {
        Configure<AbpBlobStoringOptions>(options =>
        {
            options.Containers.Configure<DigitalOceanContainer>(container =>
            {
                container.UseAws(aws =>
                {
                    aws.AccessKeyId = "your-digitalocean-access-key";
                    aws.SecretAccessKey = "your-digitalocean-secret-key";
                });
            });
        });
    }
}

Step 3: Implement a Custom S3 Client Factory

❓ Why Do We Need a Custom AmazonS3Client?

Unlike AWS S3, DigitalOcean Spaces requires setting a specific ServiceURL (e.g., https://nyc3.digitaloceanspaces.com). The default AmazonS3Client in ABP does not allow this, so we need to override the S3 client factory.

Here’s what a standard C# DigitalOcean S3 client looks like:

var config = new AmazonS3Config
{
    ServiceURL = "https://nyc3.digitaloceanspaces.com",
    ForcePathStyle = true
};

var client = new AmazonS3Client("YOUR-ACCESS-KEY", "YOUR-SECRET-KEY", config);

Since ABP doesn’t support setting the ServiceURL directly, we must replace the default S3 client factory, here’s how you override the default Amazon S3 client in ABP:

using Amazon.S3;
using Volo.Abp.BlobStoring.Aws;
using Volo.Abp.Caching;
using Volo.Abp.DependencyInjection;
using Volo.Abp.Security.Encryption;

[Dependency(ReplaceServices = true)]
[ExposeServices(typeof(IAmazonS3ClientFactory))]
public class CustomAmazonS3ClientFactory : DefaultAmazonS3ClientFactory
{
    public CustomAmazonS3ClientFactory(
        IDistributedCache<AwsTemporaryCredentialsCacheItem> cache,
        IStringEncryptionService stringEncryptionService)
        : base(cache, stringEncryptionService)
    {
    }

    public override Task<AmazonS3Client> GetAmazonS3Client(AwsBlobProviderConfiguration configuration)
    {
        var config = new AmazonS3Config
        {
            ServiceURL = "https://nyc3.digitaloceanspaces.com", // Replace with your region's endpoint
            ForcePathStyle = true
        };

        return Task.FromResult(new AmazonS3Client(configuration.AccessKeyId, configuration.SecretAccessKey, config));
    }
}

This ensures all S3 requests are correctly routed to DigitalOcean Spaces.

Step 4: Define a Blob Storage Container

To store files in DigitalOcean Spaces, create a blob container:

using Volo.Abp.BlobStoring;

[BlobContainerName("abp-digital-ocean")]
public class DigitalOceanContainer {}

Step 5: Upload Files to DigitalOcean Spaces

Inject the blob container into your service and start uploading files:

using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Volo.Abp.BlobStoring;
using Volo.Abp.DependencyInjection;

public class HelloWorldService : ITransientDependency
{
    public ILogger<HelloWorldService> Logger { get; set; }
    public IBlobContainer<DigitalOceanContainer> BlobContainer { get; }

    public HelloWorldService(IBlobContainer<DigitalOceanContainer> blobContainer)
    {
        Logger = NullLogger<HelloWorldService>.Instance;
        BlobContainer = blobContainer;
    }

    public async Task UploadFileAsync()
    {
        string filePath = "hi/hello-world.txt";
        string content = "Hello from DigitalOcean Spaces!";
        await BlobContainer.SaveAsync(filePath, content.GetBytes());

        Logger.LogInformation($"File '{filePath}' uploaded successfully.");
    }
}

Additional Blob Storing Operations

Once your integration is set up, you can retrieve, delete, and manage files easily:

Get a file:

var fileBytes = await BlobContainer.GetAllBytesAsync("hi/hello-world.txt");

Delete a file:

await BlobContainer.DeleteAsync("hi/hello-world.txt");

For more details, check the official ABP documentation

Conclusion

Using DigitalOcean Spaces with ABP’s AWS Blob Storing Provider is straightforward because DigitalOcean is S3-compatible. If ABP’s built-in AWS integration does not support setting ServiceURL, replacing the Amazon S3 Client Factory ensures seamless integration.

By following this guide, you can fully integrate DigitalOcean Spaces with ABP’s Blob Storing system and use it just like AWS S3! 🚀

In modern web development, ensuring that widgets communicate smoothly and update dynamically based on user actions is crucial. I achieved this in the ABP.IO Widgets by leveraging an event-driven approach, allowing widgets to interact seamlessly without the need for complex dependencies.

The Core Idea

Rather than having widgets tightly coupled—where one directly manipulates another—you can have them emit and listen for events. This approach keeps your code clean and your widgets reusable.

For example:

1. Categories Widget: Displays categories and triggers an event when a category is selected.
2. Courses Widget: Listens for the category selection event and refreshes the course list accordingly.
3. Courses Number Widget: Updates the course count based on the refreshed list.

Quick Implementation

Here's a brief overview of how it works:

• Categories Widget triggers a category-selected event:

(function ($) {
    abp.widgets.Categories = function ($widget) {
        var widgetManager = new abp.WidgetManager({
            wrapper: '.abp-widget-wrapper[data-widget-name="Categories"]',
            filterCallback: function () {
                return {
                    // returned values here
                };
            }
        });

        async function init() {
            // ...
            // Emit that the category selected
            $(".category-tab").off('click').on('click', function () {
                var categoryName = $(this).attr('category-name');
                $(document).trigger('category-selected', { category: categoryName });
            });
        }

        return {
            init: init,
        };
    };
    
})(jQuery);

• Courses Widget listens for this event and updates the courses:

(function ($) {
    let category = 'All'; // initial category
    abp.widgets.Courses = function ($widget) {
        var widgetManager = new abp.WidgetManager({
            wrapper: '.abp-widget-wrapper[data-widget-name="Courses"]',
            filterCallback: function () {
                return {
                    category: category
                };
            }
        });

        async function init() {
            //...
            $(document).trigger('courses-updated', { courses: filteredCourses });
        }

        function refreshCourses(_category) {
            category = _category;
            widgetManager.refresh();
        }
       
        return {
            init: init,
            refreshCourses: refreshCourses
        };
    }

})(jQuery);

• Courses Number Widget listens for the courses-updated event to update the course count:

(function ($) {
    let number = 0;
    abp.widgets.CoursesNumber = function ($widget) {
        var widgetManager = new abp.WidgetManager({
            wrapper: '.abp-widget-wrapper[data-widget-name="CoursesNumber"]',
            filterCallback: function () {
                return {
                    number: number
                };
            }
        });
        async function init() {
            $('#number').text(number);
        }
        async function refreshCoursesNumber($number) {
            number = $number;
            widgetManager.refresh();
        }
        return {
            init: init,
            refreshCoursesNumber: refreshCoursesNumber
        };
    };
})(jQuery);

To link the widgets and ensure they refresh based on emitted events, you can hard-code this on the page containing the widgets or use the script field if you’re working within the ABP CMS Kit pages feature.

This setup makes your widgets flexible and easy to manage. Place them anywhere on the page, and they’ll work together effortlessly.

By using event-driven communication, you simplify your development process and make your application more scalable and easier to maintain. Try it in your next project!

Happy coding 😁❤️

I am excited to announce that we have a new helpful CMS feature 😁!

What's the Marked Item Feature?

Imagine being able to easily flag your favorite blog posts or star important products. The Marked Item system does just that. It allows users to mark items with icons or emojis, making it super easy to keep track of what’s important to them. This nifty addition lets users mark any kind of resource, like blog posts or products, as favorites, starred, flagged, or bookmarked.

Key Features

1. Marked Toggling Component:

   • Users can mark items using customizable icons or emojis. This makes the user experience more interactive and fun!
   • Here’s a quick example of how you can use it:

     @await Component.InvokeAsync(typeof (MarkedItemToggleViewComponent), new
     {
         entityId = "...",
         entityType = "product",
         needsConfirmation = true // (optional)
     })
     

2. Simple Configuration:

   • You can easily set up your own entity types and mark types (like favorite or starred).
   • Just add this configuration in your YourModule.cs:

     Configure<CmsKitMarkedItemOptions>(options =>
     {
         options.EntityTypes.Add(
             new MarkedItemEntityTypeDefinition(
                 "product",
                 StandardMarkedItems.Favorite
             )
         );
     });
     

How to Enable the Marked Item Feature

By default, the CMS Kit features are turned off. Here’s how to turn on the Marked Item feature in your application:

1. During Development: Use the Global Feature system.
2. At Runtime: Use the ABP Framework's Feature System.

Check the "How to Install" section of the CMS Kit Module documentation to see how to enable/disable CMS Kit features on development time.

Filtering on Marked Items

Users can filter their marked items to easily find their favorites. Here’s how to utilize the GetEntityIdsFilteredByUserAsync method to filter the user's marked items within your repository queries:

List<string> entityIdFilters = null;
if (userId.HasValue)
{
    entityIdFilters = await UserMarkedItemRepository.GetEntityIdsFilteredByUserAsync(userId.Value, entityType, cancellationToken: cancellationToken);
}

var queryable = (await GetDbSetAsync())
    .WhereIf(entityIdFilters != null, x => entityIdFilters.Contains(x.Id.ToString()));
// Additional query logic...

Conclusion

This new feature excites me much, and I hope it adds even more engagement and user experience to your apps. Try it out and see how it can enhance your applications.

Happy coding!