v24.2 Release Notes
- 15 minutes to read
Tip
Visit our website to explore the latest features across the DevExpress product line: What’s New in the Latest Version.
#.NET 9 Support
XAF UI and Web API Service fully support .NET 9 (v24.2.2+).
#.NET 8, .NET Framework 4.6.2, Visual Studio 2019 - Minimally Supported Versions
Learn more about this global (v24.2+) change in the following announcement.
To simplify the migration process, the DevExpress Project Converter will attempt to re-target your XAF projects to .NET 8 automatically.
We will also try to update 3rd party packages to the latest compatible versions, where possible (for example, System.Text.Json, Microsoft.AspNetCore., Microsoft.EntityFrameworkCore., etc.) - almost 200 known dependencies in our Directory.Packages.props file.
This automation should save hours of manual effort especially for those XAF customers with large .NET Framework or .NET solutions. Of course, if your team already uses props files and Central Package Management (CPM), then you can skip our Project Converter and update everything manually.
#Source Builder - .NET Core Support and Usability Enhancements
Our new Source Builder ships as part of the DevExpress Unified Component Installer: ~\DevExpress 24.2\Components\Tools\Components\DevExpress.SourceBuilderTool.exe
. The tool rebuilds the source code used for .NET Core product libraries (previously we supported only .NET Framework).
The DevExpress Source Builder has the following system and environment requirements:
- Visual Studio 2022 and ASP.NET MVC 3 (if you rebuild DevExpress MVC projects)
- .NET 8 SDK and .NET Framework 4.6.2 Developer Pack (download)
- NuGet.exe version 6.0 (or higher) must be in the same folder as
DevExpress.SourceBuilderTool.exe
(download nuget.exe) - Node Package Manager (NPM) (install npm)
Run the following command with admin rights to rebuild DevExpress assemblies and NuGet packages (including localized assemblies/packages for German (DE), Japanese (JA), and Spanish (ES)):
DevExpress.SourceBuilderTool.exe "c:\program files\devexpress 24.2\components" -nuget
#EF Core and XPO ORM
#EF Core 9 Support
EF Core 9 support officially ships in v24.2 for XAF and associated Backend Web API Service. EF Core 9 (or EF9) is the latest production-ready version of Entity Framework.
For more information about recent EF Core updates, refer to the following Microsoft documents:
#EF Core - Calculated Fields
We implemented a simpler solution for server-side calculated fields in EF Core. Note that you can sort, group, or filter List View data by calculated properties in Server and InstantFeedback modes.
Use DevExpress.ExpressApp.DC.CalculatedAttribute
or DevExpress.ExpressApp.DC.PersistentAliasAttribute
to indicate whether a property’s value is calculated. The following code snippet demonstrates how to create a class with a calculated property:
using DevExpress.ExpressApp.DC;
public class Product : BaseObject {
// ...
public virtual decimal Quantity { get; set; }
public virtual decimal Price { get; set; }
[PersistentAlias("Quantity * Price")]
// or [Calculated("Quantity * Price")]
public decimal TotalPrice {
get { return EvaluateAlias<decimal>(); }
}
}
#EF Core - Soft Deletion
v24.2 supports EF Core soft deletion (aka XPO’s Deferred Deletion) for both XAF UI and Web API Service-powered apps.
With soft or deferred object deletion, the ORM marks objects as deleted and does not physically remove them from the database immediately. This technique helps avoid database exceptions when deleting objects referenced by other entities.
We have also created an automatic converter for existing database tables (to add the new GCRecord column). For additional information in this regard, please review the following: Core - Database and data model code changes for XAF EF Core apps to support Soft/Deferred Deletion.
#EF Core - Filtering Capabilities Are Now on Par with XPO ORM
v24.2 introduces calculated properties for EF Core in XAF (see above). This change necessitated easy access to custom IsExactType and IsInstanceOfType functions regardless of the ORM used in an application.
To achieve parity, we moved custom IsExactType and IsInstanceOfType functions from the DevExpress.Xpo assembly to the DevExpress.Data assembly (see the following ticket for additional information: XPO - The IsExactType and IsInstanceOfType custom functions has been moved to the DevExpress.Data assembly).
The change allows this feature to work in EF Core. We would also like to mention that you can use the following features in EF Core projects: Upcasting (Combine Data from Base and Derived Classes) and Free Joins (Query Non-Associated Data & Calculate Aggregations). This makes EF Core filtering capabilities no different from what is available in XPO ORM today.
#XPO - DateOnly/TimeOnly Support
In v24.2, XAF supports DateOnly/TimeOnly in XPO connection providers for .NET apps. This enhancement benefits XAF/Reporting/Dashboards and other products since XPO is at the core of data access code internally. As part of this, we also changed column mappings for SQL types Date and Time.
For more information on DateOnly/TimeOnly enhancements at the UI level of XAF WinForms apps (in grid and other controls), please review the following articles: v24.1 (WinForms), v24.2 (WinForms, Blazor).
#XPO - Connection Provider Updates
We now support the most recent versions of the following database engines (for both .NET and .NET Framework):
- PostgreSQL 17.0
- Microsoft SQL Server 2022+
- Oracle 23ai
- MySQL 9.0
- Firebird 5.0
#Cross-Platform Enhancements
#Passkeys and MFA Support with Microsoft Entra ID, Google, and Other Auth Providers
XAF UI (Blazor and WinForms) and the Web API Service offer a “1-click” solution to incorporate modern OAuth2 authentication providers with native Single Sign-On (SSO), Multi-Factor Authentication (MFA), and other security features. This works for both EF Core and XPO ORM. For details, see Active Directory and OAuth2 Authentication Providers in ASP.NET Core Blazor Applications.
Passkeys use your device lock (e.g., fingerprint, face, pin, or pattern) to sign in to accounts. For example, Microsoft Authenticator enables key-based authentication tied to a device, using a PIN or biometrics. Windows Hello for Business uses a similar technology.
With v24.2, XAF UI and Web API Service support all Passkey-related usage scenarios, including restoring forgotten passwords, account recovery, face recognition login, OTP, QR codes, and more.
#Audit Trail Module Enhancements
XAF now automatically excludes all non-persistent properties from the audit trail in XPO-based applications. This enhancement improves performance when setter methods for non-persistent properties contain extensive logic.
To update existing apps, set the static ObjectAuditProcessor.ExcludeNonPersistentFromAudit
property to true
. For additional information, please review the following: Audit - Non Persistent Properties are Excluded from the Audit Log (XPO).
#Conditional Appearance Module Enhancements
With v24.2, Appearance rules apply to nested editors of a reference property expanded into a DetailView or ListView. For example, assume you have a Department
class with an Appearance rule set for its Name
property (a yellow background color based on a condition), and an Employee
class that has a Department
reference property marked with the ExpandObjectMembers.Always
attribute. If you open an Employee
object detail or list form, its Department.Name
sub-property will include a yellow background if the same condition is met.
[Appearance("TextBackColor", AppearanceItemType = "ViewItem", TargetItems = "Name", Criteria = "Office == '1'", BackColor = "LightYellow")]
public class Department: BaseObject {
public virtual string? Name { get; set; }
}
public class Employee: BaseObject {
[ExpandObjectMembers(ExpandObjectMembers.Always)]
public virtual Department? Department { get; set; }
}
#API Usability Enhancements
XAF v24.2 includes several API usability enhancements, such as the ShowViewInPopupWindow
method for advanced DialogController configurations and new shortcuts to manage user logins and impersonation with the SignInManager
and UserManager
APIs.
The new CustomizeViewItemControl
extension method reduces the amount of code by half and allows customizing View Item controls inside a DashboardView. Here’s an example:
using DevExpress.ExpressApp.Blazor.Editors;
protected override void OnActivated() {
base.OnActivated();
View.CustomizeViewItemControl<StaticTextViewItem>(this, item => {
item.ComponentModel.UseMarkupString = true;
});
}
#Central Package Management (CPM)
XAF v24.2 Solution Wizard includes a Central Package Management (CPM) option. This feature creates a Directory.Packages.props
file at the root of your repository and sets the MSBuild property ManagePackageVersionsCentrally
to true
. Microsoft describes CPM’s main value as follows:
Dependency management is a core feature of NuGet. Managing dependencies for a single project can be easy. Managing dependencies for multi-project solutions can prove to be difficult as they start to scale in size and complexity. In situations where you manage common dependencies for many different projects, you can leverage NuGet’s central package management (CPM) features to do all of this from the ease of a single location.
The Directory.Packages.props
file (including 3rd party dependencies) can be updated by the DevExpress Project Converter based on known GitHub security advisories (GitHub advisories).
#Control Field Visibility for Various UI Contexts Declaratively
XAF v24.2 introduces a new HideInUI
attribute for use within business classes. This declarative approach simplifies the process of hiding fields from ListView, DetailView, and various other UI contexts (e.g., the Field List of the Filter, Report, and Dashboard Editor/Designer). You no longer need manual Controller-based solutions or multiple non-flexible VisibleInXXX
and Browsable
attributes.
XAF v24.2 also unifies runtime layout customization. You can now use two CustomizationFormEnabled
options (global and View-specific) instead of the former four options.
Breaking Change: EnableColumnChooser and CustomizationEnabled options replaced by CustomizationFormEnabled
#Performance Enhancements
#Blazor Rendering Speed
In v24.2, we eliminated extra page re-rendering operations in multiple XAF Blazor UI scenarios.
- Reduced re-render count for ViewSiteControl and Layout Component (for example, active tab changes in tabbed layout groups or expand/collapse operations in regular layout groups).
- Split View now re-renders only when DetailView is changing.
- Reduced re-render count in MainPageBase and Blazor Templates (the ApplicationWindow and NestedFrame templates render only once).
- Immediate switching tabs in Tabbed MDI and initial View opening from the navigation control.
- Grid renders only once per sorting, grouping, selection, and other user interactions.
- Loading dialog is now visible until the main menu toolbar is loaded.
- No components are re-rendered on the ViewChanging/Frame.Closing events.
- Closing tabs in Tabbed MDI no longer loads the tab content for inactive and unloaded tabs.
- Reduced re-render count of ComponentModelObserver for all Razor components.
To see these changes in action, compare our Outlook-Inspired Demo v24.1 vs v24.2:
#Blazor Grid List Editors
XAF Blazor DxGridListEditor and WinForms GridListEditor now support DataView, ServerView, and InstantFeedbackView data access modes for the best possible performance against large ListView data sets (for both EF Core and XPO ORM). Calculated properties are also supported.
#Audit Trail Module for XPO
We optimized indices used for AuditDataItemPersistent and other audit tables in the database. This change substantially reduces audit-related save operations:
Sample Usage Scenario | v24. |
v24. |
---|---|---|
Test #1 (10 runs) Small database (<1000 objects and audit records) | 2. |
8. |
Test #2 (10 runs) Large database (1 million objects, 3 million audit records) | 4. |
172. |
#Security and Appearance Rules with Criteria Based on Large EF Core Collections
We optimized security system configurations with multiple Member and Object permissions (as well as Conditional Appearance rules) when associated criteria involve large EF Core collections (XPO optimizations may be added in 2025).
#Key Enhancements
Loading objects and calculating security permissions with associated collections:
Criteria:[Collection][Value > 10].Exists()
Calculating security permissions with Free Joins:
Criteria:[<SomeType>][Value > 10].Exists()
Rendering ListView with Conditional Appearance Rules:
Criteria:[Collection][Value > 10].Exists()
#Image Loading
We optimized image/icon load operations across all supported platforms. We noticed improvements in application startup time of up to 2 seconds (or more in complex applications with numerous Actions (>500)).
#CriteriaOperator Evaluation
Internally, we utilized CriteriaCompiler instead of CriteriaEvaluator for security Object and Member Permissions (EF Core and XPO ORM) and Calculated Fields (EF Core only). This cut calculation time and memory allocations in half for specific usage scenarios.
#ASP.NET Core Blazor UI
#Tree List Editor
XAF Blazor v24.2 includes a DxTreeListEditor (powered by the DevExpress Blazor DxTreeList). The new List Editor is a part of the system DevExpress.ExpressApp.Blazor module (like DxGridListEditor, it offers simpler configuration options for XAF developers).
Like similar List Editors in XAF’s WinForms/WebForms UI, DxTreeListEditor
works with ITreeNode-based business classes for both EF Core and XPO ORM. It also supports business classes that do not implement ITreeNode (use the KeyFieldName and ParentKeyFieldName properties in the Model Editor).
This new List Editor also supports the following:
- Inline and batch editing (in Client data access mode)
- Data validation
- Unsaved data confirmation
- Conditional Appearance rules
- Data export
- Filtering options (Auto-Filter Row, Column Header Filters, Filter Editor)
- Column Chooser
- Context Menus for rows and column headers
#Lookup Property Editor
We migrated the underlying component used for XAF’s Blazor LookupPropertyEditor from DxComboBoxLegacy to DxComboBox (officially released in v24.1). Please review the following behavioral changes for additional information:
- ComboBox, TagBox - Search and filter behavior has been changed
- ComboBox, TagBox - The drop-down list opening and closing behavior changed
- ComboBox, TagBox - Keyboard navigation behavior has been changed
You should not notice API-related changes to your LookupPropertyEditor customization code.
#New FileData Type Property Editor
DxFileDataPropertyEditor is the default property editor (for new and existing ASP.NET Core Blazor projects) within the File Attachments module. The previous editor (FileDataPropertyEditor) is now in maintenance mode.
The new DxFileDataPropertyEditor is powered by our Blazor File Input component. It allows users to upload accepted file types using the FileTypeFilter attribute.
#Nullable Type Support within Property Editors
You can define nullable properties in your data models for both EF Core and XPO ORM (for example: int?, DateTime?, Nullable<TimeOnly>). Built-in Property and List Editors will correctly display these nullable values.
You can also remove custom solutions for non-initialized System.DateTime values (non-nullable), which might unexpectedly display 1/1/0001
(the Blazor Date Property Editor correctly displays an empty string, just as it does in XAF-based WinForms/WebForms apps).
#Extended .NET DateOnly/TimeOnly Support
XAF Blazor’s Filter Editor now supports DateOnly/TimeOnly types. At the UI level, DateOnly/TimeOnly work as expected in both EF Core and XPO-based usage contexts.
#Error Handling Enhancements
With v24.2, XAF Blazor apps can output additional error information during debugging (using a browser’s developer tools - F12 is no longer needed). In addition, non-critical exceptions do not crash the entire app and display a popup dialog instead (much like XAF WinForms UI). You can also continue execution after encountering errors rather than a complete restart.
#New Action Type - ActionUrl
XAF Blazor v24.2 includes a new Action type - ActionUrl. ActionUrl redirects a browser to a specified web page and helps you introduce complex navigation scenarios. This Action can reside in both inline (inside List Editors) and standalone Action Containers.
using DevExpress.ExpressApp;
using DevExpress.ExpressApp.Actions;
// ...
public class ActionUrlController : ViewController {
ActionUrl urlAction;
public ActionUrlController() {
urlAction = new ActionUrl(this, "ShowUrlAction", "ListView");
urlAction.SelectionDependencyType = SelectionDependencyType.RequireSingleObject;
urlAction.UrlFieldName = "Text";
urlAction.UrlFormatString = "http://www.google.com/?q={0}";
urlAction.TextFormatString = "Caption for {0}";
urlAction.TextFieldName = "Text";
}
}
#Tabbed MDI Enhancements
Tabbed MDI is the multiple document interface (MDI) metaphor found in many modern applications (including your favorite Web browser or Microsoft Outlook Web). It is a robust interface that maximizes screen real estate, especially when working with multiple documents, email messages, etc. Tabbed MDI is enabled in XAF Blazor and WinForms apps by default.
XAF Blazor v24.2 adds tab context menu support (Close, Close All But This, Close All) and allows users to close a tab by using a middle-mouse click. XAF also stores the last active tab in the Application Model and restores it when you restart the application.
#HTML Markup Support within the Rich Text Property Editor
XAF Blazor v24.2 supports DocumentStorageFormat = Html for the RichTextPropertyEditor. You can change this property via the Model Editor to support HTML markup rather than RTF (default).
#Default Caption or Image in Action Container with Drop-Down Menu
In previous versions, action containers with drop-down menus required a default action which was displayed inside the container. In this instance, when the drop-down menu was opened, it displayed all actions except the default. Based on user feedback, we have changed this behavior in this release cycle.
You can now leave the container without a default action and set a custom caption and image for the container instead. These captions and images will always be displayed regardless of which action is currently selected. In this instance, all actions added to the container are added to the drop-down menu.
Toolbar.AddActionContainer("DropdownContainer", isDropDown: true, caption: "Actions", imageName: "Action_Search");
#New Asynchronous API Shortcuts
In XAF Blazor v24.2, you can safely execute code from a background thread. The new BlazorApplication.InvokeAsync method helps you avoid concurrency issues in XAF Blazor apps:
Task.Run(async () => {
await blazorApplication.InvokeAsync(async () => {
await Task.Delay(1000);
View.ObjectSpace.Refresh();
Application.ShowViewStrategy.ShowMessage("Data refreshed");
});
});
#AI-powered Enhancements
XAF Blazor and XAF WinForms-powered apps automatically derive all AI-related features available in DevExpress components for each supported UI platform. You can either access underlying UI controls and enable AI features as necessary OR create custom XAF Property Editors/user controls/forms based on AI-powered DevExpress controls like the Chat control.
#Examples:
- Blazor Rich Text Editor (XAF’s Office Module)
- Blazor Report Viewer (XAF’s Reporting Module)
- Blazor AI chat integrations and other community content (by Joche Ojeda)
DevExpress AI-powered APIs allow you to integrate the following AI services into your DevExpress-powered application:
- OpenAI
- Azure OpenAI
- Ollama
#NOTE
DevExpress does not offer a REST API or ship any built-in LLMs/SLMs. Instead, we follow the BYOL (“bring your own license”) principle. To use these features, you need to have an active subscription to AI services (e.g., Azure, Open AI, Google Gemini, Mistral AI, etc.) and obtain the REST API endpoint, key, and model deployment name. These variables must be specified at runtime to enable DevExpress AI-powered features in your application.
For additional information, please review the following documents:
- Overview
- DevExpress AI-powered Extensions for WinForms
- AI-powered Behaviors in Rich Text and Spreadsheet Editors for WinForms
- AI-powered Blazor Chat Component