AutoFilterer Documentation

To support advanced query logic, the library introduces two specific types:

1. OperatorFilter<T>: Used for struct types to handle various comparison operators.
2. StringFilter: A specialized type designed specifically for string-based filtering operations.

By default, multiple filtering parameters are combined using the AND (&&) operator. You can change this behavior to use the OR (||) operator by setting the CombineWith property on your filter DTO.

If you are using Swagger, CombineWith appears as an enum parameter:

• 0 (or CombineType.And): Combines parameters with && (Default).
• 1 (or CombineType.Or): Combines parameters with ||.

This allows you to switch between strict filtering (all conditions must be met) and broad filtering (any condition can be met) dynamically.

// Default behavior (AND):
// Query: /Blogs?priority.min=4&isPublished=false
// Result: x => x.Priority > 4 && x.IsPublished == false

// OR behavior:
// Query: /Blogs?priority.min=4&isPublished=false&combineWith=1
// Result: x => x.Priority > 4 || x.IsPublished == false

You can define custom complex types (like a Range<T> object) that have their own specific expression generation logic. To do this, create a class that implements the IFilterableType interface and provide your own implementation of the BuildExpression() method. AutoFilterer will automatically use this method when it encounters the type in a filter DTO.

// Example pattern for a custom type
public class MyCustomType : IFilterableType
{
    // Implement BuildExpression to define how this type translates to a LINQ expression
    public Expression BuildExpression(Expression expressionBody, PropertyInfo property, object value) 
    {
        // Custom logic here
    }
}

The OperatorFilter<T> is used to perform dynamic comparisons on types that implement the IComparable interface (such as numeric fields). It implements IFilterableType, allowing it to be used as a property type within a FilterBase object. Unlike static filters, both the comparison operator and the comparison value are provided by the client via the query string.

public class BookFilter : FilterBase
{
    public OperatorFilter<int> TotalPage { get; set; }
}

It is important to understand the difference in how queries are generated for string properties:

1. StringFilterOptions (Default behavior): Often generates queries using method calls, for example: x => x.Title.Equals("something", StringComparison.InvariantCultureIgnoreCase). This may fail on providers like MongoDB.
2. [OperatorComparison] attribute: Generates queries using direct operators, for example: x => x.Title == "something". This is the recommended approach for database providers that do not support the .Equals() method translation.

AutoFilterer is a filtering framework for .NET designed to automatically generate LINQ expressions for Entities based on DTO (Data Transfer Object) filter models.

Key Concepts:

• LINQ Expression Generation: The library does not generate database queries directly; instead, it generates LINQ expressions that you can apply to an IQueryable (e.g., an Entity Framework DbSet).
• DTO Mapping: You define a filter model (DTO) where property names should match the corresponding Entity properties.
• OpenAPI Compatibility: Unlike oData or GraphQL, AutoFilterer is designed to be compatible with OpenAPI 3.0 specifications.