Following situation doesn't work for Country.Name:

 public class CityFilterDto : BaseFilterDto
 {
     [CompareTo("Name", "Country.Name")]
    [StringFilterOptions(StringFilterOption.Contains)]
    public string Filter { get; set; }
}

• Expected Expression is:
  .Where(x => x.Name.Contains("Turkey") || x.Country.Name.Contains("Turkey"))

• Generated Expression is
  .Where(x => x.Name.Contains("Turkey").Where(x.Name.Contains("Turkey")))

• Attribute instances can be cached and reused with Singleton pattern instead of creating a new instance each time.
  See new instances are created here:

  AutoFilterer/src/AutoFilterer/Types/StringFilter.cs

  Lines 60 to 75 in a10328c

  	expression = expression.Combine(new OperatorComparisonAttribute(OperatorType.Equal).BuildExpression(expressionBody, targetProperty, filterProperty, Eq), CombineWith);
  	if (Not != null)
  	expression = expression.Combine(new OperatorComparisonAttribute(OperatorType.NotEqual).BuildExpression(expressionBody, targetProperty, filterProperty, Not), CombineWith);
  	if (Equals != null)
  	expression = expression.Combine(new StringFilterOptionsAttribute(StringFilterOption.Equals) { Comparison = Compare }.BuildExpression(expressionBody, targetProperty, filterProperty, Equals), CombineWith);
  	if (Contains != null)
  	expression = expression.Combine(new StringFilterOptionsAttribute(StringFilterOption.Contains) { Comparison = Compare }.BuildExpression(expressionBody, targetProperty, filterProperty, Contains), CombineWith);
  	if (StartsWith != null)
  	expression = expression.Combine(new StringFilterOptionsAttribute(StringFilterOption.StartsWith) { Comparison = Compare }.BuildExpression(expressionBody, targetProperty, filterProperty, StartsWith), CombineWith);
  	if (EndsWith != null)
  	expression = expression.Combine(new StringFilterOptionsAttribute(StringFilterOption.EndsWith) { Comparison = Compare }.BuildExpression(expressionBody, targetProperty, filterProperty, EndsWith), CombineWith);

Now Autofilterer generates LINQ expression using constants.

SELECT p."Name" FROM Products p WHERE p."Name" = 'SomeName'

This expression translated to SQL query with hardcoded values. It allows to execute SQL injections. Also if queries like this will be logged at production environment then sensitive data like bank card number also will be logged.
It is needed to replace constants by parameters.

SELECT p."Name" FROM Products p WHERE p."Name" = $1

To replace constant by parameter in SQL query it is needed to replace Expression.Constant by Expression.Property.

Should all attributes inherit from CompareTo ? 🤔

If it's done, Each propert comparison can be set with different operator or method comparison like following:

--

public class BookFilter : FilterBase
{
    [StringFilterOptions(StringFilterOption.Contains, "Description","Author")]
    [OperatorComparison(OperatorType.Equal, "Title")
    public string Search { get; set; }
}

Originally posted by @enisn in #7 (comment)

Related with #8
#8 (comment)

public class AdvancedFilter<T> : IFilterableType
{
    public T Eq { get; set; }
    public T Gt { get; set; }
    public T Lt { get; set; }
    public T Gte { get; set; }
    public T Lte { get; set; }

    public Expression BuildExpression(Expression expressionBody, PropertyInfo targetProperty, PropertyInfo filterProperty, object value)
    {
        // Implementation goes here
        throw new NotImplementedException();
    }
}

public class BookFilter : FilterBase
{
    [CompareTo("Title", "Author")]
    public AdvancedFilter<string> Search { get; set; }
}

New types

• OperatorFilter type is required with gt, gte, lt, lte, eq, neq
  This makes obsolete Range, because it contains range filtering options, too.

• StringFilter type is with parameters: contains, startswith, endswith, etc.

Problem

By default, Range<T> doesn't include null values, it generates only GTE (>=) and LTE (<=) comparison. So null values don't match these arithmetic comparison because they're not greater or lesser, they're just NULL.

Since the ArraySearchFilterAttribute by default returns Expression.Constant(true) if the array is empty or not passed, an OR query that has other filter criteria will always return everything as the resulting expression becomes something like:

x => (True OrElse (x.DateCreated >= 7/9/2023 2:20:07 PM)

This obviously is always simply true and so as long as the array attribute exists and is not passed other criteria are effectively ignored. Notably AND queries work as normal with this implementation since it is just one of many expressions that should evaluate to true.

We have solved this issue for ourselves by creating an attribute that inherits from ArraySearchFilterAttribute that simply returns null if the array is empty, which seems to fix it for OR as well as AND queries.

How is the ArraySearchFilterAttribute supposed to work, is this described functionality correct? If not, I can open a quick PR to apply our fix to the ArraySearchFilterAttribute for inclusion in a future release.

.net 6 added the ability to use the IIncrementalGenerator interface.
Would be nice to consider using that for better performance.
I heard with the old one, if somebody types a character, it takes up to 15 minutes before they can type another character which is not acceptable.

Related with #20

Files

Awaiting implementation in 2 files:

• SelectorFilterBase.cs
  https://github.com/enisn/AutoFilterer/blob/feature/select-expression/src/AutoFilterer/Types/SelectorFilterBase.cs#L14-L18

• SelectorPaginationFilterBase.cs
  https://github.com/enisn/AutoFilterer/blob/feature/select-expression/src/AutoFilterer/Types/SelectorPaginationFilterBase.cs#L10-L14

Documentation

Also, Implementation requires documentation too. Issue #20 can help to prepare documentation.

Tests

Basics tests are ready like below, but more tests are required to handle most of scenarios.

https://github.com/enisn/AutoFilterer/blob/feature/select-expression/tests/AutoFilterer.Tests/Types/SelectorFilterBaseTests.cs

Create an app that has heavy filtering & reporting via using AutoFilterer

Exception occurred when using range filtering

Project information：abp v8.1.3

filter model

public class MyFilterRequestDto : FilterBase
 {
      public virtual Range<DateTime> CreateTime { get; set; }
}

2024-05-29 15:26:11.303 +08:00 [ERR] Conversion failed when converting date and/or time from character string.
Microsoft.Data.SqlClient.SqlException (0x80131904): Conversion failed when converting date and/or time from character string.
   at Microsoft.Data.SqlClient.SqlConnection.OnError(SqlException exception, Boolean breakConnection, Action`1 wrapCloseInAction)
   at Microsoft.Data.SqlClient.SqlInternalConnection.OnError(SqlException exception, Boolean breakConnection, Action`1 wrapCloseInAction)
   at Microsoft.Data.SqlClient.TdsParser.ThrowExceptionAndWarning(TdsParserStateObject stateObj, Boolean callerHasConnectionLock, Boolean asyncClose)
   at Microsoft.Data.SqlClient.TdsParser.TryRun(RunBehavior runBehavior, SqlCommand cmdHandler, SqlDataReader dataStream, BulkCopySimpleResultSet bulkCopyHandler, TdsParserStateObject stateObj, Boolean& dataReady)
   at Microsoft.Data.SqlClient.SqlDataReader.TryHasMoreRows(Boolean& moreRows)
   at Microsoft.Data.SqlClient.SqlDataReader.TryReadInternal(Boolean setTimeout, Boolean& more)
   at Microsoft.Data.SqlClient.SqlDataReader.ReadAsyncExecute(Task task, Object state)
   at Microsoft.Data.SqlClient.SqlDataReader.InvokeAsyncCall[T](SqlDataReaderBaseAsyncCallContext`1 context)
--- End of stack trace from previous location ---
   at Microsoft.EntityFrameworkCore.Query.Internal.BufferedDataReader.BufferedDataRecord.InitializeAsync(DbDataReader reader, IReadOnlyList`1 columns, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Query.Internal.BufferedDataReader.InitializeAsync(IReadOnlyList`1 columns, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Query.Internal.BufferedDataReader.InitializeAsync(IReadOnlyList`1 columns, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Storage.RelationalCommand.ExecuteReaderAsync(RelationalCommandParameterObject parameterObject, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Storage.RelationalCommand.ExecuteReaderAsync(RelationalCommandParameterObject parameterObject, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Query.Internal.SplitQueryingEnumerable`1.AsyncEnumerator.InitializeReaderAsync(AsyncEnumerator enumerator, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.SqlServer.Storage.Internal.SqlServerExecutionStrategy.ExecuteAsync[TState,TResult](TState state, Func`4 operation, Func`4 verifySucceeded, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Query.Internal.SplitQueryingEnumerable`1.AsyncEnumerator.MoveNextAsync()
   at Microsoft.EntityFrameworkCore.Query.ShapedQueryCompilingExpressionVisitor.SingleAsync[TSource](IAsyncEnumerable`1 asyncEnumerable, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Query.ShapedQueryCompilingExpressionVisitor.SingleAsync[TSource](IAsyncEnumerable`1 asyncEnumerable, CancellationToken cancellationToken)
   at Volo.Abp.Application.Services.AbstractKeyReadOnlyAppService`5.GetListAsync(TGetListInput input)
   at Castle.DynamicProxy.AsyncInterceptorBase.ProceedAsynchronous[TResult](IInvocation invocation, IInvocationProceedInfo proceedInfo)
   at Volo.Abp.Castle.DynamicProxy.CastleAbpMethodInvocationAdapterWithReturnValue`1.ProceedAsync()
   at Volo.Abp.GlobalFeatures.GlobalFeatureInterceptor.InterceptAsync(IAbpMethodInvocation invocation)
   at Volo.Abp.Castle.DynamicProxy.CastleAsyncAbpInterceptorAdapter`1.InterceptAsync[TResult](IInvocation invocation, IInvocationProceedInfo proceedInfo, Func`3 proceed)
   at Castle.DynamicProxy.AsyncInterceptorBase.ProceedAsynchronous[TResult](IInvocation invocation, IInvocationProceedInfo proceedInfo)
   at Volo.Abp.Castle.DynamicProxy.CastleAbpMethodInvocationAdapterWithReturnValue`1.ProceedAsync()
   at Volo.Abp.Validation.ValidationInterceptor.InterceptAsync(IAbpMethodInvocation invocation)
   at Volo.Abp.Castle.DynamicProxy.CastleAsyncAbpInterceptorAdapter`1.InterceptAsync[TResult](IInvocation invocation, IInvocationProceedInfo proceedInfo, Func`3 proceed)
   at Castle.DynamicProxy.AsyncInterceptorBase.ProceedAsynchronous[TResult](IInvocation invocation, IInvocationProceedInfo proceedInfo)
   at Volo.Abp.Castle.DynamicProxy.CastleAbpMethodInvocationAdapterWithReturnValue`1.ProceedAsync()
   at Volo.Abp.Authorization.AuthorizationInterceptor.InterceptAsync(IAbpMethodInvocation invocation)
   at Volo.Abp.Castle.DynamicProxy.CastleAsyncAbpInterceptorAdapter`1.InterceptAsync[TResult](IInvocation invocation, IInvocationProceedInfo proceedInfo, Func`3 proceed)
   at Castle.DynamicProxy.AsyncInterceptorBase.ProceedAsynchronous[TResult](IInvocation invocation, IInvocationProceedInfo proceedInfo)
   at Volo.Abp.Castle.DynamicProxy.CastleAbpMethodInvocationAdapterWithReturnValue`1.ProceedAsync()
   at Volo.Abp.Auditing.AuditingInterceptor.InterceptAsync(IAbpMethodInvocation invocation)
   at Volo.Abp.Castle.DynamicProxy.CastleAsyncAbpInterceptorAdapter`1.InterceptAsync[TResult](IInvocation invocation, IInvocationProceedInfo proceedInfo, Func`3 proceed)
   at Castle.DynamicProxy.AsyncInterceptorBase.ProceedAsynchronous[TResult](IInvocation invocation, IInvocationProceedInfo proceedInfo)
   at Volo.Abp.Castle.DynamicProxy.CastleAbpMethodInvocationAdapterWithReturnValue`1.ProceedAsync()
   at Volo.Abp.Uow.UnitOfWorkInterceptor.InterceptAsync(IAbpMethodInvocation invocation)
   at Volo.Abp.Castle.DynamicProxy.CastleAsyncAbpInterceptorAdapter`1.InterceptAsync[TResult](IInvocation invocation, IInvocationProceedInfo proceedInfo, Func`3 proceed)
   at lambda_method3601(Closure, Object)
   at Microsoft.AspNetCore.Mvc.Infrastructure.ActionMethodExecutor.AwaitableObjectResultExecutor.Execute(ActionContext actionContext, IActionResultTypeMapper mapper, ObjectMethodExecutor executor, Object controller, Object[] arguments)
   at Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker.<InvokeActionMethodAsync>g__Logged|12_1(ControllerActionInvoker invoker)
   at Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker.<InvokeNextActionFilterAsync>g__Awaited|10_0(ControllerActionInvoker invoker, Task lastTask, State next, Scope scope, Object state, Boolean isCompleted)
   at Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker.Rethrow(ActionExecutedContextSealed context)
   at Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker.Next(State& next, Scope& scope, Object& state, Boolean& isCompleted)
   at Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker.<InvokeInnerFilterAsync>g__Awaited|13_0(ControllerActionInvoker invoker, Task lastTask, State next, Scope scope, Object state, Boolean isCompleted)
   at Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.<InvokeNextExceptionFilterAsync>g__Awaited|26_0(ResourceInvoker invoker, Task lastTask, State next, Scope scope, Object state, Boolean isCompleted)
ClientConnectionId:c5d7060c-8d9e-4950-9ae6-f51fdeb3bb96
Error Number:241,State:1,Class:16
2024-05-29 15:26:11.303 +08:00 [ERR] ---------- Exception Data ----------
HelpLink.ProdName = Microsoft SQL Server
HelpLink.ProdVer = 15.00.4198
HelpLink.EvtSrc = MSSQLServer
HelpLink.EvtID = 241
HelpLink.BaseHelpUrl = https://go.microsoft.com/fwlink
HelpLink.LinkId = 20476

CodeFactor found an issue: Complex Method

It's currently on:
src\AutoFilterer\Types\StringFilter.cs:90-153
Commit 1851ded

Swagger UI supports multiple selection from listbox like following example:
https://petstore.swagger.io/#/pet/findPetsByStatus

Check if AutoFilterer supports it or not.

This issue covers following actions:

• Unit Tests
• Test App (Sandbox)
• Test App (Production - Deploy & test with real-case)

I have a sample Filter below which i'm trying to use a date range filter with in asp.net core 7, i'm not that this might be limitation of asp.net minimal API, if there's a solution any suggestion will be appreciated.

Filter sample

public class ClaimFilter : GenericFilter {
    [CompareTo("Description", "Notes", CombineWith = CombineType.And)]
    [StringFilterOptions(StringFilterOption.Contains)]
    public string? Search { get; set; }

    public ClaimStatus[]? Status { get; set; }

    public Range<DateTime> CreatedAt { get; set; }

    // Current work around
    // [CompareTo("CreatedAt")]
    // [OperatorComparison(OperatorType.GreaterThanOrEqual)]
    // public DateTime? StartDate { get; set; }
    //
    // [CompareTo("CreatedAt")]
    // [OperatorComparison(OperatorType.LessThanOrEqual)]
    // public DateTime? EndDate { get; set; }
}

Minimal API sample

group.MapGet("/", async (ClaimService sv, [AsParameters] ClaimFilter filter) =>
                await sv.GetAllAsync(filter))
            .WithName($"GetAll{name}")
            .WithOpenApi();

Error message

An unhandled exception has occurred while executing the request.
      System.InvalidOperationException: Body was inferred but the method does not allow inferred body parameters.
      Below is the list of parameters that we found:

      Parameter           | Source
      ---------------------------------------------------------------------------------
      sv                  | Services (Inferred)
      Search              | Query String (Inferred)
      Status              | Query String (Inferred)
      StartDate           | Query String (Inferred)
      EndDate             | Query String (Inferred)
      CreatedAt           | Body (Inferred)
      Page                | Query String (Inferred)
      Sort                | Query String (Inferred)
      PerPage             | Query String (Inferred)
      SortBy              | Query String (Inferred)
      CombineWith         | Query String (Inferred)
      filter              | As Parameter (Attribute)

      Did you mean to register the "Body (Inferred)" parameter(s) as a Service or apply the [FromServices] or [FromBody] attribute?

Filtering and data transferring should be separated and filtering should be injected from IoC container.

The Goal

Future of AutoFilterer aims to be a markup design pattern instead of using comparisons and binary operations.

Features

There are some planned features will be included in v3

Chaining Attributes

AutoFilterer will allow chaining multiple filter attributes with Binary operator attributes such as And & Or.
See following example

public MyFilterDto : FilterBase
{
    [StringFilterOptions(StringFilterOption.Contains)]
    [Or]
    [StringFilterOptions(StringFilterOption.StartsWith)]
    public string Title { get; set; }
}

Comparision Selection

AutoFilterer will allow choosing target property for comparison type. For example, your ToLowerContains comparison will be applied to Title but, Equal filter will be applied to Language

public MyFilterDto : FilterBase
{
    [CompareString(StringFilterOption.Contains, "Description")]
    [And]
    [CompareOperator(OperatorType.Equal, "Title")]
    public string Search { get; set; }
}

I would like to just ignore sorting when an invalid sort option in provided. Today two possible exceptions are thrown here and here.

I would like to have an option to opt-out of throwing an exception.

I have such filter:

public class StudentInfoShortResponseFilter : PaginationFilterBase
{
    [CompareTo(nameof(StudentInfoShortResponse.FullName),
        nameof(StudentInfoShortResponse.AcademicGroup),
        nameof(StudentInfoShortResponse.StudentIdCard),
        nameof(StudentInfoShortResponse.Institute))]
    [StringFilterOptions(StringFilterOption.Contains)]
    [ToLowerContainsComparison]
    public string? Search { get; set; }
}

And when I'm trying to write in 'search' anything - it always gives me all records, not filtering it.
StudentInfoShortResponse.Institute - enum type.
If I'll delete this from attribute - it will search for other properties.

With such enum property in filter attribute it stops write filter in query.

If I'll write

public Institute? Institute {get;set;}

in filter - all will be fine too.

Create a TODO App with CRUD operations via using AutoFilterer

See the origin of this issue:
#35

Possible Scenarios

There are 6 possibilities while generating filters for collections. 2 of them are already covered by AutoFilterer currently. Those possibilities depend on Property types of Filter and Source Objects. When a Filter object property is a collection, the query must be generated with Contains method. But there is more a couple of possibilities:

• p => []
• [] => {}
• [p] => [p] (Contains method inside Any/All method. For MongoDb models)
• [{}]=> [{}] ( Built Expression ({} => {}) inside All/Any methodto understand how to generate query.)

p property
[] array
[p] a property inside array
[{}] entire object inside array

Summary

This feature aims to generate an expression for .Select() Linq method.

Declaration

See usage example for better understanding:

• Entity

public class Book
{
  public string Name { get; set; }

  public int TotalPage { get; set; }

  public DateTime CreateDate { get; set; }

  public virtual ICollection<BookOrder> BookOrders { get; set; }
}

• FilterDto (As always but inherits SelectorFilterBase)

public class BookFilterDto : SelectorFilterBase<BookDto>
{
  [ToLowerContainsComparison]
  public string Name { get; set; }

  public Range<int> TotalPage { get; set; }

  public Range<DateTime> CreateDate { get; set; }
}

• Output dto:

public class BookDto
{
  [From("Name")]
  public string Title { get; set; }

  public int TotalPage { get; set; }

  public DateTime CreateDate { get; set; }

  [Count("BookOrders")]
  public int SellCount { get; set; }

  [Sum("BookOrders.Price")]
  public float TotalSoldPrice { get; set; }
}

Usage

As default, SelectorFilterBase should override ApplyFilter() method, so calling ApplyFilter method will work.

[HttpGet]
public IActionResult GetBooks([FromQuery] BookFilterDto filter)
{
    var query = db.Books.ApplyFilter(filter);  // IQueryable<BookDto>
    return Ok(query.ToList());
}

• Or alternative usage:

As default, SelectorFilterBase should override ApplyFilter() method, so calling ApplyFilter method will work.

[HttpGet]
public IActionResult GetBooks([FromQuery] BookFilterDto filter)
{
    var query = db.Books.ApplySelector(filter)  // IQueryable<BookDto>
                            .Where(x => x.TotalSoldPrice > 299.95); // If db provider supports.

    return Ok(query.ToList());
}

Structure

• FilterBase
  • OrderableFilterBase
    • PaginationFilterBase
      • SelectorFilterBase

TODO List

• Extension methods for last user usage
• SelectorFilterBase and SelectorPaginationFilterBase implementation.
• Attributes
  • Sum
  • Count
  • Min
  • Max
  • Average

I have an idea related to the "Custom Expression for a Property" feature mentioned in your documentation. My idea is to make the FilteringOptionsBaseAttribute support generics, which would make writing LINQ expressions easier. Do you think this is possible?

For reference, here is another project that might be helpful:
https://github.com/ClaveConsulting/Expressionify
https://github.com/lukemcgregor/LinqExpander

Thank you for considering my suggestion.

May I ask how to use a query based on PaginationFilterBase to return a paged data result, which should have two values of TotalPages and TotalItems to display on the pagination control of datagrid component；
Hope to get your reply, thank you

Because of my thoughts from here: https://youtu.be/fKgsE3j-6rU?si=71Y-f9xvFkwWYhST

Dynamic filtering is not one of the goals of this library. Dynamic filtering doesn't cover the Open API Specifications, and this library doesn't stand for dynamic filtering. In the next version (v3.0) I'll drop the AutoFilterer.Dynamic support.

Also it blocks the PR #69

https://enisn-projects.io/docs/en/AutoFilterer/ return 404

there is my code:

Enable Source Linking for all packages according to:
https://github.com/dotnet/sourcelink/blob/main/README.md#using-source-link-in-net-projects

Only two of them is enough:

    <PublishRepositoryUrl>true</PublishRepositoryUrl>
    <IncludeSymbols>true</IncludeSymbols>

I'm Currently trying out AutoFilterer and it works well with using FromBody but not with FromQuery

Below are the full error message generated, i'm sticking to using FromBody for not just wanted to report the issue.

Microsoft.AspNetCore.Http.RequestDelegateFactory.BindParameterFromValue(ParameterInfo parameter, Expression valueExpression, RequestDelegateFactoryContext factoryContext, string source)
Microsoft.AspNetCore.Http.RequestDelegateFactory.CreateArgument(ParameterInfo parameter, RequestDelegateFactoryContext factoryContext)
Microsoft.AspNetCore.Http.RequestDelegateFactory.CreateArguments(ParameterInfo[] parameters, RequestDelegateFactoryContext factoryContext)
Microsoft.AspNetCore.Http.RequestDelegateFactory.CreateArgumentsAndInferMetadata(MethodInfo methodInfo, RequestDelegateFactoryContext factoryContext)
Microsoft.AspNetCore.Http.RequestDelegateFactory.InferMetadata(MethodInfo methodInfo, RequestDelegateFactoryOptions options)
Microsoft.AspNetCore.Routing.RouteEndpointDataSource.CreateRouteEndpointBuilder(RouteEntry entry, RoutePattern groupPrefix, IReadOnlyList<Action> groupConventions, IReadOnlyList<Action> groupFinallyConventions)
Microsoft.AspNetCore.Routing.RouteEndpointDataSource.GetGroupedEndpoints(RouteGroupContext context)
Microsoft.AspNetCore.Routing.RouteGroupBuilder+GroupEndpointDataSource.GetGroupedEndpointsWithNullablePrefix(RoutePattern prefix, IReadOnlyList<Action> conventions, IReadOnlyList<Action> finallyConventions, IServiceProvider applicationServices)
Microsoft.AspNetCore.Routing.RouteGroupBuilder+GroupEndpointDataSource.get_Endpoints()
Microsoft.AspNetCore.Routing.CompositeEndpointDataSource.CreateEndpointsUnsynchronized()
Microsoft.AspNetCore.Routing.CompositeEndpointDataSource.EnsureEndpointsInitialized()
Microsoft.AspNetCore.Routing.DataSourceDependentCache.Initialize()
System.Threading.LazyInitializer.EnsureInitializedCore(ref T target, ref bool initialized, ref object syncLock, Func valueFactory)
Microsoft.AspNetCore.Routing.Matching.DataSourceDependentMatcher..ctor(EndpointDataSource dataSource, Lifetime lifetime, Func matcherBuilderFactory)
Microsoft.AspNetCore.Routing.Matching.DfaMatcherFactory.CreateMatcher(EndpointDataSource dataSource)
Microsoft.AspNetCore.Routing.EndpointRoutingMiddleware.InitializeCoreAsync()
Microsoft.AspNetCore.Routing.EndpointRoutingMiddleware.g__AwaitMatcher|8_0(EndpointRoutingMiddleware middleware, HttpContext httpContext, Task matcherTask)
Swashbuckle.AspNetCore.SwaggerUI.SwaggerUIMiddleware.Invoke(HttpContext httpContext)
Swashbuckle.AspNetCore.Swagger.SwaggerMiddleware.Invoke(HttpContext httpContext, ISwaggerProvider swaggerProvider)
Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddlewareImpl.Invoke(HttpContext context)