Skip to main content
All docs
V24.2

DevExpress v24.2 Update — Your Feedback Matters

Our What's New in v24.2 webpage includes product-specific surveys. Your response to our survey questions will help us measure product satisfaction for features released in this major update and help us refine our plans for our next major release.

Take the survey Not interested

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.

Documentation | Blog Post

The DevExpress Project Converter - XAF for Blazor, DevExpress

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)):

bash
DevExpress.SourceBuilderTool.exe "c:\program files\devexpress 24.2\components" -nuget

Documentation

#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:

C#
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>();  } 
  } 
} 

Documentation

#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.

Documentation

#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.

Documentation

#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

Documentation

#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.

The Log In window - XAF for Blazor, DevExpress

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.

The fingerprint screen lock - XAF for Blazor, DevExpress

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.

C#
[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; }
}

An XAF app with the Conditional Appearance module - XAF for Blazor, DevExpress

#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:

C#
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.

Control field visibility - XAF for Blazor, DevExpress

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.2 (s) v24.1 (s)
Test #1 (10 runs) Small database (<1000 objects and audit records) 2.94 8.97
Test #2 (10 runs) Large database (1 million objects, 3 million audit records) 4.33 172.37

#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

  1. Loading objects and calculating security permissions with associated collections:
    Criteria: [Collection][Value > 10].Exists()
    IsGranted Check by criteria with not loaded collection for many objects (EF Core) - XAF for Blazor, DevExpress

  2. Calculating security permissions with Free Joins:
    Criteria: [<SomeType>][Value > 10].Exists()
    IsGranted Check by criteria with FreeJoins for many objects (EF Core) - XAF for Blazor, DevExpress

  3. Rendering ListView with Conditional Appearance Rules:
    Criteria: [Collection][Value > 10].Exists()
    Render ListView with Conditional Appearance Criteria with not loaded collection for many objects (EF Core) - XAF for Blazor, DevExpress

#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.

IsGranted Check, many objects (Time) - XAF for Blazor, DevExpress

IsGranted Check, many objects (Allocation) - XAF for Blazor, DevExpress

#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

The ASP.NET Core Blazor Tree List Editor - XAF for Blazor, DevExpress

#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:

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.

Breaking Change

#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.

The Application Error window - XAF for Blazor, DevExpress

#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.

C#
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.

The drop-down context menu in Tabbed MDI - XAF for Blazor, DevExpress

#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.

C#
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:

C#
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:

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:

See Also