DxFilterBuilder.CustomizeOperators Event

Allows you to customize criteria operator lists in the Filter Builder component.

Namespace: DevExpress.Blazor

Assembly: DevExpress.Blazor.v25.2.dll

NuGet Package: DevExpress.Blazor

Declaration

[Parameter]
public Action<FilterBuilderCustomizeOperatorsEventArgs> CustomizeOperators { get; set; }

Parameters

Type	Description
FilterBuilderCustomizeOperatorsEventArgs	An object that contains data for this event.

Remarks

When a user creates or changes a filter condition, the Filter Builder populates the criteria operator list with corresponding items. Handle the CustomizeOperators event to customize the list.

You can use the following event arguments:

DefaultOperator

Specifies the default operator item.

FieldName

Returns the data source field.

FieldType

Returns the field data type.

Operators

Returns a collection of associated operator items.

ShowGroups

Specifies whether the Filter Builder arranges criteria operators into groups.

The following code snippet adds a custom operator for DateTime fields and specifies a custom criteria list for the Amount field:

Razor

<DxFilterBuilder CustomizeOperators="CustomizeOperators" >
    <Fields>
        <DxFilterBuilderField FieldName="Subject" Caption="Name" Type="@typeof(string)" />
        <DxFilterBuilderField FieldName="CreatedDate" Caption="Created Date" Type="@typeof(DateTime)" />
        <DxFilterBuilderField FieldName="Amount" Caption="Amount" Type="@typeof(int)" />
        <DxFilterBuilderField FieldName="Discontinued" Type="@typeof(bool)" />
    </Fields>
</DxFilterBuilder>


@code {
    void CustomizeOperators(FilterBuilderCustomizeOperatorsEventArgs args) {
        if(args.FieldName == "Amount") {
            args.Operators.Clear();
            args.Operators.Add(new FilterBuilderOperatorItem(FilterBuilderOperatorType.Equals));
            args.Operators.Add(new FilterBuilderOperatorItem(FilterBuilderOperatorType.Greater));
            args.Operators.Add(new FilterBuilderOperatorItem(FilterBuilderOperatorType.Less));
            args.DefaultOperator = args.Operators[FilterBuilderOperatorType.Less];
            args.ShowGroups = true;
        }
        if(args.FieldType == typeof(DateTime)) {
            FilterBuilderOperatorItem thisMonthOperator = args.Operators[FilterBuilderOperatorType.IsThisMonth];
            thisMonthOperator.Caption = "Falls in this month";

            var customItem = new FilterBuilderOperatorItem(IsEarlierThisMonth.Instance.Name) {
                GroupName = "Custom functions"
            };
            args.Operators.Add(customItem);
        }
    }
}

CustomFunction.cs

using DevExpress.Data.Filtering;

class IsEarlierThisMonth : ICustomFunctionOperator, ICustomFunctionDisplayAttributes {
    public static IsEarlierThisMonth Instance { get; } = new IsEarlierThisMonth();

    public static void Register() => CriteriaOperator.RegisterCustomFunction(Instance);
    public static bool Unregister() => CriteriaOperator.UnregisterCustomFunction(Instance);

    private IsEarlierThisMonth() { }

    public string Name => nameof(IsEarlierThisMonth);
    public string DisplayName => "Is earlier this month";
    public object Image => null;
    public int MinOperandCount => 1;
    public int MaxOperandCount => -1;
    public string Description => "Function description";
    public FunctionCategory Category => FunctionCategory.DateTime;

    public object Evaluate(params object[] operands) {
        DateTime dateTime;
        if(operands[0] is DateOnly dateOnly)
            dateTime = dateOnly.ToDateTime(TimeOnly.MinValue);
        else
            dateTime = Convert.ToDateTime(operands[0]);
        DateTime today = DateTime.Today;
        DateTime startOfMonth = new DateTime(today.Year, today.Month, 1);
        return dateTime >= startOfMonth && dateTime < today;
    }

    public bool IsValidOperandCount(int count) => count == 1;

    public bool IsValidOperandType(int operandIndex, int operandCount, Type type) => type == typeof(DateTime) || type == typeof(DateOnly);

    public Type ResultType(params Type[] operands) => typeof(bool);

}

Program.cs

// ...
IsEarlierThisMonth.Register();
// ...
app.Run();

Refer to the following article for additional information and examples: Filter Operators in Blazor Filter Builder.