v25.1 Release Notes

• Aug 11, 2025
• 15 minutes to read

Tip

Visit our website to explore new features across the entire DevExpress product line: What’s New in the Latest Version.

License Keys — New in v25.1

This new release requires every developer/build machine to store a DevExpress license key associated with your account. DevExpress Unified Installer (Windows) automatically obtains your License Key and places it into its correct location. Run the installer in Repair/Register mode to update your key when necessary. If you used our Unified Installer before license keys were introduced (prior to v25.1), you should not experience any changes when installing or updating DevExpress products. If you bypass the DevExpress Unified Installer, you can download your license key and register it in the system manually (via a file on disk or an environment variable). Review detailed instructions in the following help topic: Online NuGet Feeds, CI/CD, and Other Installation Methods (Windows, macOS, Linux).

ASP.NET Core Blazor UI

Grid and Tree List Editor Enhancements

Relative Splitter Position

The IModelSplitLayout.RelativePosition property determines the splitter’s position in relation to the DetailView as a percentage (when MasterDetailMode = ListViewAndDetailView). It is automatically set when a user adjusts the splitter and takes precedence over the pixel-based SplitterPosition property.

Extended Context Menu

Our DxGridListEditor includes new Best Fit and Clear Sorting context menu commands for grid column headers.

PDF Export Support

With v25.1 you can export List View content to PDF. Both DxTreeListEditor and DxGridListEditor support this capability.

To customize export settings, subscribe to the CustomizeGridExport event and use the DocumentOptions property:

using DevExpress.Blazor;
using DevExpress.ExpressApp;
using DevExpress.ExpressApp.Blazor.SystemModule;

public class CustomizeExportControllerBlazor : ViewController<ListView> {
    private BlazorExportController blazorExportController;
    protected override void OnActivated() {
        base.OnActivated();
        blazorExportController = Frame.GetController<BlazorExportController>();
        // Subscribe to CustomizeGridExport event.
        blazorExportController.CustomizeGridExport += blazorExportController_CustomizeGridExport;
    }
    void blazorExportController_CustomizeGridExport(object sender, GridExportEventArgs e) {
        // Export only selected rows in PDF.s
        if (e.DocumentOptions != null) {
            e.DocumentOptions.ExportSelectedRowsOnly = true;
        }
    }
    protected override void OnDeactivated() {
        blazorExportController.CustomizeGridExport -= blazorExportController_CustomizeGridExport;
        base.OnDeactivated();
    }
}

Virtual Scrolling Mode

You can now enable virtual scrolling mode (instead of traditional pagination) for your List View:

Banded Layout

v25.1 adds support for Banded layouts (much like XAF WinForms):

Middle Tier Security (CTP)

XAF Blazor now supports Middle Tier Security for secure communication between the frontend and backend, helping to protect sensitive data and enforce stricter access controls.

See also: T1295981 - MiddleTierSecurityOptions and EFCoreMiddleTierSecurityOptions have been moved to different namespaces and NuGet packages

Read Tutorial: Documentation

Razor Component support for Control Detail Items

XAF Blazor v25.1 includes a new BlazorControlViewItem so you can integrate custom ASP.NET Core Blazor components within a Detail View. This new class simplifies the creation of view items (it offers setup within a single razor file and reduces the amount of code you’d otherwise need to write).

Masks for Date and Time properties

XAF Blazor Date and Time Property Editors support masked input. The EditMask property restricts user input and can be specified in the Application Model: BOModel > YourBusinessClass > Property > EditMask. You can also customize mask settings for TimeOnly - TimeSpan and DateOnly – DateSpan type pairs separately in code.

View.CustomizeViewItemControl<TimeSpanPropertyEditor>(this, editor => {
    // TimeSpan
    editor.DxTimeEditMaskProperties.DateTime.CaretMode = MaskCaretMode.Advancing;
    // TimeOnly
    editor.DxTimeEditMaskProperties.TimeOnly.CaretMode = MaskCaretMode.Regular;
});

ToolTip Attribute Enhancements

XAF Blazor v25.1 supports the following UI elements for the ToolTip attribute (and the IModelToolTip.ToolTip property in the Application Model):

• Navigation groups and items
• DxGridListEditor and DxTreeListEditor column headers
• Layout group headers

[ToolTip("View, assign or remove employees for the current task")]
public virtual IList<Employee> Employees { get; set; }

Enhanced Keyboard Support - Menu Shortcuts

As part of ongoing Accessibility (A11Y) investments for both XAF and DevExpress UI components, XAF developers will be able to specify appropriate keystroke combinations in the Model Editor or in code (similar to XAF WinForms with its ActionBase.Shortcut API). In addition to A11Y benefits, this will also facilitate CRUD operations for end-users (for example, to save changes, create, or delete records). Examples:

• New: Ctrl+Shift+A
• Save: Ctrl+Shift+S
• Logon: Enter
• DialogOK: Ctrl+Shift+Enter
• Refresh: Ctrl+Shift+R
• Delete: Ctrl+Delete
• NextObject: Ctrl+Alt+RightArrow
• PreviousObject: Ctrl+Alt+LeftArrow
• SaveAndClose: Ctrl+Shift+Enter

Enhanced Filtering by Non-Persistent Fields

With this release, XAF’s FilterController (and other XAF APIs working with server-side criteria) process non-persistent business class properties in Client data access mode more efficiently (for EF Core). Once non-persistent properties are detected in ListView criteria, XAF fully processes it on the client side.

XAF Blazor v25.1 also removes non-persistent/non-aliased properties (see 1-2 below) from the FilterPropertyEditor menu/user selection for both EF Core and XPO ORM (for example, defined with the NotMapped attribute). Calculated properties defined with the PersistentAlias and Calculated attributes are NOT removed (see 3-4 below). This change impacts our standalone Filter Editor in both the DetailView and ListView when DataAccessMode is not Client.

See also: T1287746 - FullTextSearchAction - Non-persistent properties are now included in full text search for Client data access mode

.NET Aspire Integration

Our team has spent some time considering the capabilities of Aspire, isolating the best integration points and allowing XAF developers to take advantage of Aspire orchestration features out of the box. The team sees Aspire as a potential “1-click solution”, a more modern alternative to some templates in the XAF Solution Wizard. Benefits include:

• Simplify long and error-prone setup processes like those we describe in our documentation for Azure App Service and Nginx support on Linux, as well as other popular web server configurations.
• Provision required databases and other application resources for both development and deployment environments (for instance, using a Docker setup).

Our goal is to help save time, whether using XAF or not. Much of this remains a moving target, since Microsoft continues to evolve Aspire. At the same time, some functionality is already used and is considered stable. As such, we decided to publish details to help you make use of Aspire-specific tools in your own XAF project. Please refer to the following documents for additional information:

• .NET Aspire Support for an XAF Blazor Project- Introduction
• Custom Telemetry, Service Orchestration, Database Dependency

Simplified Chart Control Integration

XAF Blazor v25.1 introduces a new DxChartListEditor based on the DxChart<T> component. The editor takes a Razor file as input (with required graph layout and series settings). XAF ASP.NET Core Blazor binds the underlying control to current View data automatically.

DxChartListEditor supports popular chart types, such as Line, Area, Bar, Point, Range, Financial, Pie and Donut, Polar, Sparklines, Histogram, and Drill Down.

To create a Chart View in your XAF Blazor application, you must:

1. Create a Razor component and specify DxChart‘s configuration components. For example:

   File: CS\MainDemo.Blazor.Server\Charts\PaycheckSettings.razor

   @using DevExpress.Blazor
   @using MainDemo.Module.BusinessObjects
   
   <DxChartLineSeries Name="Gross Pay"
                   ArgumentField="(Paycheck p) => p.PaymentDate"
                   ValueField="(Paycheck p) => p.GrossPay"
                   SummaryMethod="Enumerable.Sum" />
   <DxChartLineSeries Name="Net Pay"
                   ArgumentField="(Paycheck p) => p.PaymentDate"
                   ValueField="(Paycheck p) => p.NetPay"
                   SummaryMethod="Enumerable.Sum" />
   

   Ensure that the Razor file’s Build Action property is set to Content.

2. Invoke the Model Editor for your ASP.NET Core Blazor project and create a List View node in Model Editor that defines a List View to be visualized as a chart. Set the EditorType property of the node to DxChartListEditor.

3. In the Model Editor, navigate to the required List View, and set the SettingsTypeName property to the full name of your Razor component.

   

You can also specify chart settings in code:

File: CS\MainDemo.Blazor.Server\Controllers\MyBlazorController.cs

using System;
using DevExpress.ExpressApp;
using DevExpress.ExpressApp.Blazor.Editors;

namespace MainDemo.Blazor.Server.Controllers;
public class MyBlazorController : ViewController<ListView> {
    protected override void OnViewControlsCreated() {
        base.OnViewControlsCreated();
        if (View.Editor is DxChartListEditor chartListEditor) {
            // Place your chart configuration code here.
            chartListEditor.ChartModel.Width = "100%";
        }
    }
}

For more information about DxChartListEditor, refer to the following topic: Chart Module.

DisplayFormat Support in XAF Lookup Property Editor

In v25.1, Lookup Property Editor columns support the DisplayFormat property:

Control Over Navigation Panel Visibility at Startup

You can now control initial visibility of the navigation panel in your XAF-powered Blazor application. Set the ShowNavigationOnStart property to false to collapse the Navigation Panel at application startup.

Fluent UI Theme and Icons

Just over a year ago, Microsoft released a new Outlook for Windows and macOS with a modern and simplified design. This updated version of Outlook offers a streamlined, web–integrated experience that aligns with Microsoft’s Fluent 2 design standards. Many of our customers have expressed interest in replicating this contemporary UI within their own DevExpress-powered desktop and web applications. If you’ve used the new version of Outlook, you know that Microsoft’s new user experience extends far beyond simple UI enhancements:

• The app’s sidebar extends up to the form title, optimizing vertical space to display more menu items on–screen.
• The sidebar can be ‘collapsed’ using the Ribbon’s hamburger button, allowing for a more compact layout.
• The Ribbon control and form title can host additional UI elements, including buttons, a search panel, and other interactive UI components.
• Fluent UI enhancements include semi–transparent effects, colorful flat icons, rounded corners, specious paddings, and more.

We expect to support Fluent and Ribbon UI in XAF Blazor-powered apps at the end of 2025 (v25.2). For v25.1, we completed required research and implemented the following:

• Added support for new Fluent Dark and Light themes for key UI controls (the Report Viewer, Designer and other UI components will be supported in v25.2+).
• Created ~200 of XAF-specific icons (filled or outlined) to match the Fluent theme.
• Modified menu and layout paddings in both Compact and Standard modes (to better mimic modern Office-inspired web apps).

Note

This XAF Blazor feature is available as a Community Technology Preview (CTP) in v25.1. Fluent UI support for XAF WinForms should be officially available in v25.2+ (once support is added to corresponding DevExpress WinForms UI components).

EF Core Enhancements

Concurrency Control for EF Core

XAF Blazor/Windows Forms EF-Core based apps support Optimistic Concurrency control (on par with existing XPO ORM functionality). This capability is enabled for all classes that implement the new IOptimisticLock interface (for example, all classes inherited from XAF’s BaseObject). You can use the OptimisticLockIgnore attribute to disable this capability for selected classes or properties.

With OptimisticLockDetection and OptimisticLockHandling options you can fine-tune collision detection and merge strategies both on object-level and field-level. You can set up a combination of these options either in the Application Builder for all classes or use OptimisticLockAttribute (to specify a custom strategy for a specific class).

builder.ObjectSpaceProviders
   .AddEFCore(options =>
   {
       options.PreFetchReferenceProperties();
       options.OptimisticLockDetection = OptimisticLockDetection.AllFields;
       options.OptimisticLockHandling = OptimisticLockHandling.Merge;
   })

No breaking changes are expected for existing EF Core projects when using the DevExpress Project Converter (to handle all database changes automatically). See Also: T1273764 - Core - Database and data model code changes for XAF EF Core apps to support the Optimistic Locking

Clone Object Module for EF Core

With v25.1, XAF Blazor and Windows Forms EFCore-based apps support the Clone command. With this enhancement, you can quickly copy data records including aggregated detail collections.

We unified cloning functionality and APIs for both ORMs, so XAF developers can use a single DevExpress.ExpressApp.CloneObject package. For additional information, refer to T1276850 - Core - The DevExpress.ExpressApp.CloneObject.Xpo assembly and NuGet package have been renamed.

Easier Database Schema Updates When a New Class or Property Is Added (XPO Parity)

v25.1 simplifies database updates for EF Core developers (targeting XAF WinForms/Blazor or Web API Service-based apps). For instance, when you add a new business class or a property at design time, XAF will automatically update database structure in Debug mode (similar to XPO ORM functionality). This will save development time because no extra methods will be necessary, especially for frequent data model changes.

We also removed the redundant DBUpdater tool for .NET/.NET-based apps for EF Core and XPO ORM. XAF developers can now use the updateDatabase CLI command of the underlying application instead. This will simplify the developer experience for both deployment and maintenance because a single method will be used. For additional information, refer to T1282681 - Database schema update behavior has changed for EF Core.

Note

Do not use this automatic update in Debug mode (or -updateDatabase -forceUpdate keys of the underlying application) with production databases or other important data (if you wish to make changes to a production database, be certain to backup your data). You, the developer, are responsible for the application, database, network, and other configurations and data safety/consistency based on client, security, and environment requirements. We recommend that you review relevant database update procedures with your database administrators (DBA) and always follow network/database best-practice standards.

Simplified Connection Settings for EF Core and XPO

The Template Kit will include popular database connection options like PostgreSQL, SQL Azure, MySQL, Oracle, and SQLite (instead of just Microsoft SQL Server). Once selected, the new XAF project will automatically include all required NuGet packages and database-specific API calls like UseNpgsql for the option.

This will simplify the first-time developer experience because XAF developers will no longer need to follow manual steps or know all specificities related to EF Core or XPO connection providers.

Easier Connection to Middle-Tier Server in Non-XAF Apps for EF Core

In a Middle Tier server architecture, only the server has direct access to the database. DbContext and other EF Core CRUD APIs are still used in UI client app code (which interacts with the server remotely). Before passing data to the client’s DbContext, the server enforces security measures such as authentication, authorization, and data validation (powered by our .NET App Security API).

v25.1 includes our MiddleTierClientBuilder<TDbContext> - designed to simplify boilerplate code needed to connect non XAF-powered WinForms/WPF apps to a Middle Tier Security Server (via XAF’s Security System and EF Core). For additional information, check out our WinForms non-XAF example. Our new Template Kit will include non-XAF project templates for WinForms/WPF.

Cross-Platform Enhancements

Web API Service Enhancements

Our Backend Web API Service ships with the following highly-requested usability features for EF Core and XPO:

• OData Deep Insert and Deep Update (for Post, Patch and Put HTTP verbs).
• OData Batch Operations (aka Batch Update support).

See Also: T1291970 - DataService method signatures were changed and XafDelta<T> was marked as obsolete

Read Tutorial: Documentation

XAF Blazor and Web API Service + AntiForgery

XAF project template code (Startup.cs) now includes Antiforgery services and middleware to mitigate potential Cross-Site Request Forgery (CSRF/XSRF) attacks. This reduces implementation costs (when compared to manual implementation).

Read Tutorial: Documentation

Multi-Tenancy Enhancements

With Blazor/Web API XAF v25.1, our Multi-Tenancy module allows you to store custom data in a shared/hosted database (for both EF Core and XPO ORM). This is helpful when storing currency, tax, and other global data that needs to be accessed from any tenant. For XAF developers, it should dramatically simplify code because it is no longer necessary to set up a separate Object Space Provider for the shared database manually. The new WithSharedBusinessObjects method allows you to specify a list of shared object types:

builder.AddMultiTenancy()
    .WithSharedBusinessObjects(typeof(PersistentType1), typeof(PersistentType2), ...)
    //...

Tenants can read these shared data tables, but cannot modify data within them (or have associations with tenant data) - only service/host UI administrators have full CRUD capabilities. XAF developers also have access to standard and transparent IObjectSpace APIs to query shared data (including methods like CreateObjectSpace/CreateNonSecuredObjectSpace<T>(“YourTenantName“)).

Read Tutorial: Documentation

PDF Viewer (CTP)

XAF Blazor and XAF WinForms v25.1 ships with PDF Viewer support (available as a Community Technology Preview). With this new capability, you can display PDF file content (stored in byte[] or IFileData properties properties) directly in your XAF-powered app. As you’d expect, our implementation allows you to navigate through a PDF document, set zoom level, print, and download the desired document.

PDF Viewer is represented by the following platform-specific property editors:

ASP.NET Core Blazor

DevExpress.ExpressApp.Office.Blazor.Editors.DxPdfViewerPropertyEditor using the DxPdfViewer component.

Windows Forms

DevExpress.ExpressApp.Office.Win.PdfViewerPropertyEditor using the PdfViewer component.

To incorporate a PDF Viewer in your application, decorate the PDF file content property with the EditorAliasAttribute and pass the PdfViewerPropertyEditor value as the attribute’s parameter:

[EditorAlias(EditorAliases.PdfViewerPropertyEditor)] 
public virtual byte[] Data { get; set; }

Or set the PropertyEditorType property to DevExpress.ExpressApp.Office.Win.PdfViewerPropertyEditor / DevExpress.ExpressApp.Office.Blazor.Editors.DxPdfViewerPropertyEditor in the Model Editor.

Read Tutorial: Documentation

Data Source Filtering for Enumeration Property Editors

XAF Blazor/WinForms v25.1 support the following attributes for our Enumeration Property Editors:

• DataSourceCriteriaAttribute
• DataSourceCriteriaPropertyAttribute
• DataSourcePropertyAttribute

For example, you can filter enumeration values with the DataSourceCriteria attribute and the following criteria: “Status != 0 and Status > 2", "Status In (0,1,2)", "Status != '@This.OtherSelectedStatus'“, etc.

using DevExpress.Persistent.BaseImpl.EF;
using DevExpress.Data.Filtering;
using System.ComponentModel.DataAnnotations;

[DefaultClassOptions]
public class Order : BaseObject {
    [DataSourceCriteria("Status = ##Enum#MyNamespace.OrderStatus,Pending# || Status = ##Enum#MyNamespace.OrderStatus,Confirmed#")]
    public virtual OrderStatus Status { get; set; }
}
public enum OrderStatus { Pending, Confirmed, Processing, Shipped, Delivered, Canceled, Returned }

New Built-in Property Editors: Tag Box and Progress Bar

XAF Blazor and XAF WinForms v25.1 support DevExpress Tag Box and Progress Bar Property Editors.

Tag Box (CTP)

Tag Box is a popular option to save space in detail forms for collection data (as an alternative to large data grids).

The new Editor supports CRUD operations, Security System, Application Model options such as AllowEdit or AllowClear, DataSourceXXX filtering attributes, ImmediatePostData and other standard XAF features.

For more information about Tax Box, refer to the following topic: Collection Properties.

Progress Bar (CTP)

Progress Bar displays the progress of an operation in read-only mode. XAF measures and displays the value of the bound property in percent (supports integer and floating-point data types).

For more information about Progress Bar, refer to the following topic: Numeric Properties.