FilterControlOperationVisibilityEventArgs.CustomFunctionName Property

Gets a custom filter function name.

Namespace: DevExpress.Web

Assembly: DevExpress.Web.v24.1.dll

NuGet Package: DevExpress.Web

Declaration

C#

public string CustomFunctionName { get; }

VB.NET

Public ReadOnly Property CustomFunctionName As String

Property Value

Type	Description
String	A function name.

Remarks

Use the CustomFunctionName property to obtain the name of the custom filter function. For a comparison operator based on the custom function, the Operation property value is Function and the FunctionType property value is Custom.

Implement an Operator Based on a Custom Function

The example below demonstrates how to implement a custom operator (“Does not begin with”) for the grid’s filter builder. This operator allows users to hide grid rows whose values in the specified column begin with the entered string value.

Create a class that implements the ICustomFunctionDisplayAttributes interface to define a function displayed as an operator. This interface extends the ICustomFunctionOperatorBrowsable interface with the following properties:

DisplayName

Specifies the operator’s caption.

Image

Specifies the operator’s image. You can set this property to Image, SvgImage, and ImageProperties class instances or an image’s URL string.

The function can accept one or two operands:

• The first operand holds a field value.

• The second operand holds a user-entered value. The function compares it to the field value.

C#

using DevExpress.Data.Filtering;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

public class DoesNotBeginWithFunction : ICustomFunctionDisplayAttributes {
    public const string FunctionName = "DoesNotBeginWith";
    public static readonly DoesNotBeginWithFunction Instance = new DoesNotBeginWithFunction();
    DoesNotBeginWithFunction() { }

    #region ICustomFunctionOperatorBrowsable Members
    FunctionCategory ICustomFunctionOperatorBrowsable.Category {
        get { return FunctionCategory.Text; }
    }
    string ICustomFunctionOperatorBrowsable.Description {
        get { return "Selects items that do not start with the specified string."; }
    }
    bool ICustomFunctionOperatorBrowsable.IsValidOperandCount(int count) {
        return count == 2;
    }
    bool ICustomFunctionOperatorBrowsable.IsValidOperandType(int operandIndex, int operandCount, Type type) {
        return type == typeof(string);
    }
    int ICustomFunctionOperatorBrowsable.MaxOperandCount {
        get { return 2; }
    }
    int ICustomFunctionOperatorBrowsable.MinOperandCount {
        get { return 2; }
    }
    #endregion
    #region ICustomFunctionDisplayAttributes
    string ICustomFunctionDisplayAttributes.DisplayName {
        get { return "Does not begin with"; }
    }
    object ICustomFunctionDisplayAttributes.Image {
        get { return "~/Content/CustomFunctions/notbeginwith.svg"; }
    }
    #endregion
    #region ICustomFunctionOperator Members
    //The first operand (operands[0]) is the field value to process.
    //The second operand (operands[1]) is the value specified in the filter editor.
    object ICustomFunctionOperator.Evaluate(params object[] operands) {
        if (operands[0] != null && operands[1] != null) {
            string str1 = operands[0].ToString();
            string str2 = operands[1].ToString();
            return !str1.StartsWith(str2, StringComparison.InvariantCultureIgnoreCase);
        }
        return false;
    }
    string ICustomFunctionOperator.Name {
        get {
            return FunctionName;
        }
    }
    Type ICustomFunctionOperator.ResultType(params Type[] operands) {
        return typeof(bool);
    }
    #endregion
}

VB.NET

Imports DevExpress.Data.Filtering
Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports System.Web

Public Class DoesNotBeginWithFunction
    Implements ICustomFunctionDisplayAttributes
    Public Const FunctionName As String = "DoesNotBeginWith"
    Private Shared ReadOnly Instance As New DoesNotBeginWithFunction()
    Private Sub New()
    End Sub

    #Region "ICustomFunctionOperatorBrowsable Members"
    Private ReadOnly Property Category() As FunctionCategory Implements ICustomFunctionOperatorBrowsable.Category
        Get
            Return FunctionCategory.Text
        End Get
    End Property
    Private ReadOnly Property Description() As String Implements ICustomFunctionOperatorBrowsable.Description
        Get
            Return "Selects items that do not start with the specified string."
        End Get
    End Property
    Private Function IsValidOperandCount(ByVal count As Integer) As Boolean Implements ICustomFunctionOperatorBrowsable.IsValidOperandCount
        Return count = 2
    End Function
    Private Function IsValidOperandType(ByVal operandIndex As Integer, ByVal operandCount As Integer, ByVal type As Type) As Boolean Implements ICustomFunctionOperatorBrowsable.IsValidOperandType
        Return type Is GetType(String)
    End Function
    Private ReadOnly Property MaxOperandCount() As Integer Implements ICustomFunctionOperatorBrowsable.MaxOperandCount
        Get
            Return 2
        End Get
    End Property
    Private ReadOnly Property MinOperandCount() As Integer Implements ICustomFunctionOperatorBrowsable.MinOperandCount
        Get
            Return 2
        End Get
    End Property
    #End Region
    #Region "ICustomFunctionDisplayAttributes"
    Private ReadOnly Property DisplayName() As String Implements ICustomFunctionDisplayAttributes.DisplayName
        Get
            Return "Does not begin with"
        End Get
    End Property
    Private ReadOnly Property Image() As Object Implements ICustomFunctionDisplayAttributes.Image
        Get
            Return "~/Content/CustomFunctions/notbeginwith.svg"
        End Get
    End Property
    #End Region
    #Region "ICustomFunctionOperator Members"
    'The first operand (operands[0]) is the field value to process.
    'The second operand (operands[1]) is the value specified in the filter editor.
    Private Function Evaluate(ParamArray ByVal operands() As Object) As Object Implements ICustomFunctionOperator.Evaluate
        If operands(0) IsNot Nothing AndAlso operands(1) IsNot Nothing Then
            Dim str1 As String = operands(0).ToString()
            Dim str2 As String = operands(1).ToString()
            Return Not str1.StartsWith(str2, StringComparison.InvariantCultureIgnoreCase)
        End If
        Return False
    End Function
    Private ReadOnly Property Name() As String Implements ICustomFunctionOperator.Name
        Get
            Return FunctionName
        End Get
    End Property
    Private Function ResultType(ParamArray ByVal operands() As Type) As Type Implements ICustomFunctionOperator.ResultType
        Return GetType(Boolean)
    End Function
    #End Region
End Class

Call the CriteriaOperator.RegisterCustomFunction or CriteriaOperator.RegisterCustomFunctions method to register the custom function class.

C#

protected void Page_Init(object sender, EventArgs e) {
    CriteriaOperator.RegisterCustomFunction(DoesNotBeginWithFunction.Instance);
}

VB.NET

Protected Sub Page_Init(ByVal sender As Object, ByVal e As EventArgs)
    CriteriaOperator.RegisterCustomFunction(DoesNotBeginWithFunction.Instance)
End Sub

Initially, the filter control does not display an operator based on the created function. Handle the corresponding event to set the e.Visible property to true for the operator:

• ASPxFilterControl.OperationVisibility

• ASPxGridBase.FilterControlOperationVisibility (ASPxCardView, ASPxGridView, ASPxVerticalGrid)

• ASPxPivotGrid.FilterControlOperationVisibility

• ASPxTreeList.FilterControlOperationVisibility

ASPX

<dx:ASPxGridView ID="grid" runat="server"
    OnFilterControlOperationVisibility="grid_FilterControlOperationVisibility"...>
    <Columns>
        <dx:GridViewDataTextColumn FieldName="ProductName" />
        <!--...-->
    </Columns>
    <Settings ShowFilterBar="Visible" />
</dx:ASPxGridView>

C#

protected void grid_FilterControlOperationVisibility(object sender, FilterControlOperationVisibilityEventArgs e) {
    if (e.PropertyInfo.PropertyName == "ProductName" || e.PropertyInfo.PropertyName == "Country") {
        List<ClauseType> availableOperators = new List<ClauseType>() {
            ClauseType.BeginsWith,
            ClauseType.Contains,
            ClauseType.DoesNotContain,
            ClauseType.Like
        };
        if (availableOperators.Contains(e.Operation) ||
           (e.FunctionType == FunctionOperatorType.Custom && e.CustomFunctionName == "DoesNotBeginWith"))
            e.Visible = true;
        else
            e.Visible = false;
    }
}

VB.NET

Protected Sub grid_FilterControlOperationVisibility(ByVal sender As Object, ByVal e As FilterControlOperationVisibilityEventArgs)
    If e.PropertyInfo.PropertyName = "ProductName" OrElse e.PropertyInfo.PropertyName = "Country" Then
        Dim availableOperators As List(Of ClauseType) = New List(Of ClauseType)() From {
            ClauseType.BeginsWith,
            ClauseType.Contains,
            ClauseType.DoesNotContain,
            ClauseType.Like
        }
        If availableOperators.Contains(e.Operation) OrElse _
           (e.FunctionType = FunctionOperatorType.Custom AndAlso e.CustomFunctionName = "DoesNotBeginWith") Then
            e.Visible = True
        Else 
            e.Visible = False
        End If
    End If
End Sub