XAF Team Blog

XAF (Cross-Platform .NET App UI & Web API Service) — June 2026 Roadmap (v26.1)

Dennis Garavsky (DevExpress) — Tue, 03 Mar 2026 07:18:00 Z

Thank you for choosing XAF (Cross-Platform .NET App UI & Web API Service) for your software development needs. This blog post outlines some of our XAF-related development plans for the first half of 2026 (v26.1, set for release in June 2026).

First, if you have not heard of XAF or are new to the DevExpress product line, XAF is a developer-centric .NET application framework designed to build feature-complete Office-inspired line-of-business apps (leveraging DevExpress Blazor and WinForms UI components via Entity Framework or XPO ORM). Feel free to review our XAF demos and compare our implementation with other software low-code, no-code (LCNC) and traditional development methodologies.

The information contained within this blog post details our current/projected development plans. Please note that this information is being shared for INFORMATIONAL PURPOSES ONLY and does not represent a binding commitment on the part of Developer Express Inc. This roadmap and the features/products listed within it are subject to change. You should not rely on or use this information to help make a purchase decision about Developer Express Inc products.

Content Security Policy Enhancements

Together with our Blazor development team, we will eliminate the need to use the following content security policy (CSP) requirement: style-src: 'unsafe-inline'. For additional information in this regard please review Content Security Policy (CSP) in XAF Blazor Apps.

Template Kit Enhancements

We will add the following security and usability-related enhancements for newly created XAF projects via our new Template Kit:

Select multiple Middle Tier Security-based startup projects;
Enforce the Middle Tier Security option by default;
Migrate to the minimal API/simplified Blazor project format with no Startup.cs file (makes .NET Aspire integration much easier).

Entity Framework Core 10 for Data Access

We expect to ship official EF Core 10 support in our v26.1 release cycle (for our XAF Blazor/WinForms UI and Web API Service). EF Core 10 is the latest version of Entity Framework. For early testing, EF Core 10 support is already available in v25.2.5+. We also updated our EF Core 10 vs XPO performance benchmarks.

Our new Template Kit also uses EF Core 10 when .NET 10 is selected. Our MainDemo.NET.EFCore will also use EF Core 10 and .NET 10 in v26.1. NOTE: .NET 10 requires Visual Studio 2026, which is yet to be adopted by most users, so we have not done this for v25.2.

While EF Core 10 offers numerous advantages over its predecessor (performance and customization included), it also introduced a series of breaking changes that we needed to address. Not all EF Core database connection providers ship EF Core 10-compatible NuGet packages as of this post (like Pomelo.EntityFrameworkCore.MySql). XAF's Web API Service also uses older Swashbuckle.AspNetCore package versions with .NET 10.

DateTimeOffset Type Support for EF Core and XPO

Our dev team will implement the core in DevExpress.Data, DevExpress.Xpo and related XAF libraries (similar to what we did for DateOnly/TimeOnly in DataController, Server Mode data sources, Criteria Language, etc.). Based on this core, our data-aware UI controls (such as Data Grid, Tree List, Date Editors) for Blazor and other UI platforms will be able to do the remaining work.

If all goes according to plan, by v26.2 we will be able to support the DateTimeOffset data model properties in key XAF List and Property Editors. This synergy will simplify multiple customer use-cases where application users are spread across different time zones.

XAF Blazor Report Designer Enhancements

We will use ViewDataSource by default when creating a new report. We will also make it easier to customize XAF data source settings (data type, sorting, filtering, etc.) in the runtime Report Designer.

Filter Builder Enhancements and Pivot Grid Integration

With v26.1, we will replace our existing JS-based filter editor with the new DevExpress Blazor Filter Builder. The DevExpress Blazor Filter Builder offers simpler localization, better performance, and native Blazor theme/palette support. This change will also reduce maintenance costs for the XAF team. The following Filter Builder features are critical for XAF integration: collection operations, plain criteria text input/validation, good performance with complex data model structures.

In addition, we will improve XAF's WinForms Filter Editor when using advanced XAF and ORM-specific criteria functions (Upcasting, Free Joins, etc.).

If time permits, we will also integrate the DevExpress Blazor Pivot Table (an early preview of XAF's DxPivotGridListEditor in v26.1). This integration is based on previous v25.2 research and close collaboration with our Blazor development team (who made required extension points/APIs and added features important for XAF customers). If all goes according to plan, v26.2 should mark the official release of DxPivotGridListEditor.

Built-In AI Module to Add Smart Functions in "1-Click"

If you are unfamiliar with our existing .NET AI-powered Extensions, please review these documents. XAF Blazor/WinForms v26.1 will simplify the following AI-related capabilities:

Semantic or Smart Search within DevExpress Data Grids and AI Chat Integration

AI-Powered Smart Paste within the Detail View Layout Control

AI-Powered Extensions in the Reporting, Filter Editor, Office (Rich Text Editor) Modules

Blazor List and Property Editor Enhancements

We expect to migrate XAF's DxGridListEditor to native Blazor DxGrid component context menus, which were added in a recent major update (much like in XAF WinForms below).

We will also make it easier to add custom buttons to Blazor Property Editors in code (via the new Buttons property):

private void Customize_EnumPropertyEditor(EnumPropertyEditor editor) {
    var customButtonModel = new DxEditorButtonModel() {
        Text = "Test",
        Click = EventCallback.Factory.Create<MouseEventArgs>(this,
             (e) => Application.ShowViewStrategy.ShowMessage("Click!"))
    };
    editor.Buttons.Add(customButtonModel);
}

What's Next / Our Main Focus

We Remain Focused on XAF Blazor Scalability

As many of you already know from my mid-2025 announcement, our core focus for the next few major release cycles will continue to be scalability (number of concurrent web users). At the end of 2026 (not yet in v25.2 or v26.1), we want future XAF Blazor apps and XAF core to be:

Scalable up to hundreds and even a thousand of web users reliably and predictably.
Require simpler configuration for high-load and multi-tenancy scenarios (without Kubernetes -k8s- or other complicated horizontal/scale out solutions).
Require much less compute resources (CPU/RAM).

As I noted earlier, this is especially important as scalable, cloud-hosted, multi-tenant/SaaS-based apps are becoming a standard requirement (for both internal and public LOB deployments). Achieving desired levels of XAF Blazor scalability will certainly help customers targeting hybrid desktop apps for both Windows and non-Windows environments (Electron.NET-powered). Better scalability will also drive the evolution of our Multi-Tenancy module (scalability is an "enabler" to add additional standard SaaS features later).

Migrate Your XAF Apps from .NET Framework (WinForms/WebForms) to .NET (WinForms/Blazor)

For this big and ambitious goal, we had to drop .NET Framework support and remove legacy APIs in v25.2. We also re-balanced our dev team internally to prioritize performance enhancements in XAF Core and Blazor UI above other features. Of course, we remain focused on security and continue to address usability and other framework-related issues (as you can see from the XAF Blazor/WinForms roadmap above).

To help with the migration to .NET from .NET Framework easier, we published semi-automatic converters and detailed migration guidelines (powered by AI, Roslyn, and our Project Converter). Please let us know if there is anything we can improve in this regard for you.

Blazor Model Editor in Your Web Browser (Postponed)

In January, we confirmed that it is technically feasible to have the same experience as in XAF WinForms Model Editor (see our Blazor prototype). While I would love to have the powerful runtime Blazor Model Editor today as much as you, we intentionally delayed it in favor of our main strategic focus (web scalability). We'll see whether we can revisit this task in our v26.2 release cycle.

This Application Model / UI structure customization will also require additional licensing/EULA considerations - as this powerful tool is primarily for "developers" (application structure/logic customizations are technically considered "development" tools).

First XAF Blazor Scalability Research Results

By v26.1, we will publish the first load-testing results along with related product enhancements (safely activated via feature flags). For example, our core dev team almost finalized planned Application Model enhancements, which will reduce memory usage and speed up critical code execution under high user load.

Our primary work from mid-2025 has been and still is to:

Analyze key bottlenecks from research;
Prioritize the most impactful changes for target scenarios (like 500+ users);
Plan required code changes in XAF core and DevExpress Blazor components.

Below you can see a screenshot from our internal dashboard for a few test runs in February. The bottom chart series displays the impact on response times from one of our recent code optimizations. Of course, we must also optimize for web server memory usage, database/SQL, and many other parameters. Challenges remain, but we are sure that our final implementation will deliver positive/noticeable business impact to XAF Blazor and its users.

DevExpress Blazor Component Enhancements (for XAF Blazor)

Learn more: Blazor — June 2026 Roadmap (v26.1)

DevExpress WinForms Component Enhancements (for XAF WinForms)

Learn more: WinForms — June 2026 Roadmap (v26.1)

Other DevExpress Component Enhancements (for XAF Blazor/WinForms)

Learn more:

Your Feedback Matters

As always, we welcome your feedback. Your response to the following questions will help us fine-tune/refine plans for our next major release:

If you have yet to review the features/capabilities introduced in our most recent major update (v25.2), please visit the following webpage and let us know what you think of this release by responding to our online XAF v25.2 survey.

Thanks,
Dennis Garavsky
Principal Product Manager
dennis@devexpress.com

XAF (Cross-Platform .NET App UI & Web API Service) — Year-End Roadmap (v25.2)

Dennis Garavsky (DevExpress) — Fri, 15 Aug 2025 01:01:00 Z

EDIT: XAF v26.1 Roadmap

This blog post outlines some of our XAF-related development plans for the second half of 2025 (v25.2) and beyond. The announcement within this post is important and I don't wish to minimize its impact. My goal is to give everyone as much advance notice as possible.

XAF Blazor/WinForms UI Enhancements in v25.2 for .NET 8+

.NET 10 and Visual Studio vNext Support

We plan to officially support .NET 10 after its final release (for our XAF Blazor/WinForms UI and Web API Service).

Microsoft also announced the next major version of Visual Studio, planned for release later this year. Needless to say, will introduce support for XAF's Model Editor, WinForms and Report designers, as well as other IDE tooling/integrations.

TagBox, ComboBox, Progress Bar, PDF Viewer Property Editors: Official Release/RTM

In our v25.1 release cycle, we published these new Property Editors as a Community Technology Preview (CTP) for XAF Blazor and XAF WinForms. In v25.2, we will officially release these features.

Middle Tier Security for Blazor UI: Official Release/RTM

Our next major update (v25.2) we will also officially support XAF Blazor UI + Middle Tier Security configuration (for secure communication between the frontend and backend, helping to protect sensitive data and enforce stricter access controls). See Also: Data Store Protection (Docs) | Security-related blog articles.

Windows/macOS Desktop Support via Blazor UI & Electron.NET

The previous feature will help us publish a GitHub example with a new “hybrid” desktop app for Windows and macOS (powered by Electron.NET and XAF Blazor). In this GitHub example, an XAF Blazor app will be wrapped inside a native “web view” container for the target OS and connected to our Middle Tier application server (or database directly, if allowed). Based on user demand, we may transform this example into a Template Kit project in the future.

When used, XAF developers can deliver both Windows and non-Windows support when WinForms and browser-based apps do not meet client needs (a customer use-case). For end-users, this hybrid desktop app will feel and behave (performance-wise) no differently than Microsoft Teams, Visual Studio Code, Outlook (new), and similar hybrid apps. For many, this web-based approach can be an alternative to native WinForms/WPF/VCL/Avalonia desktop development ("write once, run everywhere").

Fluent Themes and Icons: Official Release/RTM

As first announced in our v25.1 roadmap, we expect to officially ship Dark and Light Fluent Themes for XAF Blazor v25.2 (currently in CTP). We also expect to extend our SVG icon pack with more colorful XAF-specific icons (filled or outlined) to match the Fluent Theme and its dark/light palettes.

Fluent UI style support for XAF WinForms has been postponed until v26.1 (once we finalize related WinForms component updates in v25.2).

Ribbon UI Support

With XAF v25.2, we will modify the main menu, navigation, account component, theme switcher, and layout structure (to mimic modern Office-inspired web apps). We will use the Ribbon UI (instead of a simple toolbar) and combine it with a Tabbed MDI by default (like XAF WinForms). Our implementation will support Ribbon UI command merging and better XAF Action support across both main and detail form templates (Window Controller's Actions will be processed like its done in XAF WinForms).

Configure XAF Report Data Sources within the Blazor Report Designer

With our next major release, end-users will be able to modify ViewDataSource/CollectionDataSource settings (data type, sorting, filtering, etc.) in the runtime Report Designer.

Research: Blazor Filter Builder and Pivot Grid Integration

We hope to replace our existing JS-based filter editor with the new DevExpress Blazor Filter Builder (CTP in v25.1). The DevExpress Blazor Filter Builder supports simpler localization, better performance, and native Blazor themes/palettes. This change will also reduce maintenance costs for the XAF team. The following Filter Builder features are critical for XAF integration: collection operations and plain criteria text input/validation.

We will also consider integrating the DevExpress Blazor Pivot Table (as part of the new XAF's DxPivotGridListEditor).

AI-related Enhancements

If you are unfamiliar with our existing .NET AI-powered Extensions, please review these documents.

XAF Blazor/WinForms v25.2 will simplify use of one or more AI-related capabilities from the following list:

Semantic or Smart Search within DevExpress Data Grids and Lookup editors.
Semantic or Smart Search within our Ribbon and Accordion controls.
AI-powered Smart Paste within DevExpress Data Grids and Layout controls. Smart Paste analyzes content and intelligently assigns correct values to appropriate layout fields or row cells (to transform traditional copy-and-paste operations).
AI Chat integration (including a project template).
Easier activation of AI-powered extensions in the Reporting, Filter Editor, Office (Rich Text Editor) modules.

DevExpress MCP Server for AI-Powered Documentation Access

All Platforms In Development

We will introduce an MCP server that connects GitHub Copilot Chat, Cursor, and other MCP-compatible AI tools directly to our comprehensive documentation database. The server will provide instant access to over 300,000 help topics through natural language queries within your IDE. This will allow you and AI coding agents such as Claude Code to access current DevExpress documentation directly within the AI assistant's context. Learn more: DevExpress Documentation MCP Server: Configure an AI-powered Assistant.

XAF v25.2+ Will No Longer Include .NET Framework Support (WebForms & WinForms)

What

We will officially end WebForms & WinForms .NET Framework support in our v25.2+ release cycle. We will focus our efforts on .NET 8+ (Blazor & WinForms & Web API Service) going forward. We will ship security and other critical fixes for v25.1.XX minor builds for as long as we can. Example: we will ship XAF WebForms/WinForms v25.1.XX for security-related updates and answer technical support questions even when DevExpress v27.1.3 is released (and likely beyond our standard version support policy).

We appreciate all the wonderful XAF .NET Framework-related feedback you've given us over the last 20 years. Though cancelling a .NET Framework project is not fun (nor does it help anyone's bottom line) we are confident that this decision will be a win/win for everyone.

We recommend XAF .NET Framework users migrate their apps to XAF Blazor/WinForms UI or Web API Service for .NET 8+. Our online docs include many migration guidelines (see .NET Support and Migration). The XAF team will also continue to extend these guidelines and help XAF customers with migration-related questions (in the DevExpress Support Center).

Why

While we hoped to maintain XAF legacy WebForms & WinForms apps as long as .NET Framework ships with Windows, it is no longer realistic. Reasons include:

Growing technology gap: We can no longer combine tech from 2000 (.NET Framework ASP.NET WebForms/WinForms) with a platform from 2020 (ASP.NET Core/Blazor/Web API) in the same codebase. Modern requirements for scalable, multi-tenant, and cloud-ready apps require a new XAF core/architecture.
Rising maintenance/opportunity costs: We can no longer ignore the following maintenance/opportunity costs: use of .NET Core/.NET Framework preprocessor directives; inability to leverage DI to its full potential; inability to use modern C# language/.NET SDK features (like Span<T>, Memory<T>, ReadOnlySequence<T>, just to name a few).
Embracing AI-driven change: The disruption AI brings to the table for our .NET user base requires us to evolve more rapidly and pursue non-standard solutions. This is not feasible when .NET Framework is on board.

What's Next/Main Focus

To recap: we will continue enhancing XAF Blazor UI for .NET 8+ in our year-end release. We will also maintain XAF WinForms UI for .NET 8+. We will gradually evolve XAF WinForms UI to meet modern Windows desktop standards/end-user expectations (such as Fluent UI, AI-powered functions, etc.).

Our core focus for the next few major release cycles will be scalability (number of concurrent web users). At the end of 2026 (not yet in v25.2), we want future XAF Blazor apps and XAF core to be:

Scalable up to hundreds and even a thousand of web users reliably and predictably.
Require simpler configuration for high-load and multi-tenancy scenarios (without Kubernetes -k8s- or other complicated horizontal/scale out solutions).
Require much less compute resources (CPU/RAM).

As I noted earlier, this is especially important as scalable, cloud-hosted, multi-tenant/SaaS-based apps are becoming a standard requirement (for both internal and public LOB deployments). Achieving desired levels of XAF Blazor scalability will certainly help customers targeting hybrid desktop apps for both Windows and non-Windows environments (Electron.NET-powered). Better scalability will also drive the evolution of our Multi-Tenancy module (scalability is an "enabler" to add additional standard SaaS features later).

Other Anticipated XAF v25.2+ Changes (.NET 8+)

Focus on scalability may result in the following:

XAF .NET 8+ will eliminate legacy/obsolete code. Example: legacy Domain Component interfaces (DC), SecuritySystemXXX and related security classes, not recommended for use in favor of PermissionPolicyXXX classes from 2016. Low-level API breaking changes (BC) are also expected.
XAF Blazor v25.2+ core may separate from the XAF WinForms core. Desktop and web apps are fundamentally different technically and in terms of expected user load. Think of a single-user "fat" desktop client VS a multi-user client-server/distributed web app. While we have always maximized the amount of cross-platform XAF code (for ourselves and XAF customers), the same compatibility may be challenging due to differences between desktop apps/web apps.
Core feature set changes in XAF .NET 8+. This includes Types Info, Application Model, Security System and other modules (like no more WinForms PivotChart, KPI, ScriptRecorder modules). We will also have to limit XAF Blazor flexibility in favor of scalability/performance (likely under a feature toggle). Example: high-load multi-tenant XAF Blazor apps will enforce simplified security permissions OR limited Application Model layers.

As always, we will try to minimize impact on existing customers with detailed migration guides or auto-update tooling, where possible.

Your Feedback Matters

Your response to the following questions will help us fine-tune/refine plans for our next major release:

If you have yet to review the features/capabilities introduced in our most recent major update (v25.1), please visit the following webpage and let us know what you think of this release by responding to our online XAF v25.1 survey.

Thanks,
Dennis Garavsky
Principal Product Manager
dennis@devexpress.com

XAF (Cross-Platform .NET App UI & Web API Service) — Early Access Preview (v25.1)

Dennis Garavsky (DevExpress) — Mon, 21 Apr 2025 09:18:00 Z

This post documents a few XAF-related features we expect to ship in early June and details what’s inside our Early Access Preview build. As you will note below, XAF-related focus areas remain Blazor, Entity Framework Core and Security. For additional information on what you can expect in v25.1, please refer to our June 2025 Roadmap.

If you own an active Universal Subscription, feel free to download this Early Access Preview (EAP) build at your convenience. If you own an active DXperience Subscription and would like to learn more about our Cross-Platform .NET App UI (XAF) or Web API Service, you can explore the features described herein by logging onto the DevExpress Download Manager and installing this EAP build in trial mode. Once you do, please tell us whether these new features address your business needs. Your feedback will help us fine-tune our implementation before official launch.

If you are using a trial and want to try these preview features today, you can purchase a DevExpress Universal license online (this will give you access to the early access preview build). If you own a non-Universal subscription and are ready to upgrade, email us at clientservices@devexpress.com for upgrade pricing.

ASP.NET Core Blazor UI

Grid List Editor Enhancements

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

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

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; }

Action Shortcuts

XAF Blazor v25.1 supports keyboard shortcuts for Toolbar and Context Menu Action Controls. You can specify appropriate keystroke combinations in the Model Editor or in code. 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

FilterController (and other XAF APIs working with server-side criteria) now better process non-persistent business class properties in Client data access mode for EF Core. Once non-persistent properties are detected in ListView criteria, we fully process 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).

.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 available out of the box. The team sees Aspire as a potential "1-click solution", a more modern alternative to some of the 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 you're using XAF or not. Right now, much of this is 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:

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 the 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

In v25.1, XAF Blazor and Windows Forms EFCore-based apps support the Clone command. With this, 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 apply EF Core migrations to the database 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 got rid of 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 more 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.

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 - 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 in our official release.

Cross-Platform Enhancements

Support DataSourceXXX attributes for Enumeration Property Editors

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

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: TagBox and Checked ComboBox

XAF Blazor/WinForms v25.1 ship with built-in Tag Box and Checked ComboBox Property Editors. TagBox and Checked ComboBox are two popular options to save space in detail forms for collection data (as an alternative to large data grids).

All new Editors support CRUD operations, Security System, Application Model options such as `AllowEdit` or `AllowClear`, `DataSourceXXX` filtering attributes, ImmediatePostData and other standard XAF features.

Web API Service Enhancements

Our Backend Web API Service introduces the following highly-requested usability features (for EF Core in this EAP, for XPO in the final release):

OData Deep Insert and Deep Update (for Post, Patch and Put HTTP verbs). You can now use the new Patch(DeltaSet<TEntity> deltaSet) method to create/update large amounts of objects.
OData Batch Operations (aka Batch Update support).

Your Feedback Matters!

Early Access and CTP builds are provided solely for early testing purposes and are not ready for production use. This build can be installed side by side with other major versions of DevExpress products. Please backup your project and other important data before installing Early Access and CTP builds. This EAP may not include all features/products we expect to ship in our v25.1 release cycle. As its name implies, the EAP offers an early preview of what we expect to ship in two months.

We recommend you try out the new features using Visual Studio 2022 and either MainDemo.NET.EFCore or MainDemo.NET.XPO demo (located in the following folder: "c:\Users\Public\Documents\DevExpress Demos 25.1\Components\XAF\"). You can also test the EAP build against your project, but please remember that this build is not ready for production use.

We will keep you posted about additional features we expect to ship in v25.1 (see our June 2025 Roadmap) as we get closer to official release. If you've had the opportunity to use the EAP build, please post your thoughts in our roadmap survey OR create a Support Center ticket. We will happily follow up.

Thanks,
Dennis Garavsky
Principal Product Manager
dennis@devexpress.com

XAF (Cross-Platform .NET App UI & Web API Service) — June 2025 Roadmap (v25.1)

Dennis Garavsky (DevExpress) — Mon, 17 Feb 2025 01:31:00 Z

EDIT: XAF v25.2 Roadmap

Blazor UI Enhancements

Fluent Theme and Ribbon UI Support

Just over a year ago, Microsoft released a new Outlook for Windows 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. This involves, but is not limited to:

Dark and light Fluent theme support.
Creating hundreds of XAF-specific icons (filled or outlined) to match the Fluent theme.
Modifying menu and layout structures (to mimic modern Office-inspired web apps).

NOTE: Since both DevExpress Blazor Ribbon and Fluent UI are currently available as a Community Technology Preview (for instance, the ribbon control has no Classic or multi-line view), we do not expect complete support in XAF Blazor v25.1 (likely in v25.2). Fluent UI support for XAF WinForms should be officially available in v25.2 as well (once support is added to corresponding DevExpress WinForms UI components).

Accessibility Enhancements

As part of our ongoing Accessibility (A11Y) investments for both XAF and DevExpress UI components, XAF Blazor v25.1 will support keyboard shortcuts for menu commands or Actions. 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 accelerate CRUD operations for many end-users (for example, to save changes, create, or delete records).

Grid List Editor Enhancements

XAF Blazor v25.1 will support the following (for DxGridListEditor):

Banded layout (much like in XAF WinForms).
Double-click instead of a single-click to open a detail form from a ListView (much like in WinForms).
Easier context menu customization for both grid rows and column headers.
New "Best Fit" and "Clear Sorting" context menu commands for grid column headers.
Virtual/infinite scrolling in all root and nested ListViews instead of a pager (much like in XAF WinForms).
The new IModelSplitLayout.RelativePosition property to specify the splitter position relative to the DetailView in percentage (when MasterDetailMode = ListViewAndDetailView). RelativePosition takes priority over the IModelSplitLayout.SplitterPosition property (in pixels).
Simplified API to access column settings for Grid List Editors across all XAF UI platforms. For example, you will be able to write platform-agnostic code (see below) or access platform-specific settings via ColumnWrapper descendants:

protected override void OnViewControlsCreated() {
    base.OnViewControlsCreated();
    if (View.Editor is ColumnsListEditor listEditor) {
        foreach (var column in listEditor.Columns) {
            column.ShowInCustomizationForm = false;
        }
    }
}

XAF Blazor v25.1 will support 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

Simplified Chart, HTML Editor, and PDF Viewer Integration

With v25.1, we expect to reduce the amount of code needed to integrate popular UI elements such as Charts, HTML Editor, and PDF Viewer (you can check the current code required in our Outlook-Inspired Demo). We do expect to build XAF WinForms/WebForms module counterparts, because these DevExpress Blazor components are totally different, so it will not be possible to reuse cross-platform features such as common layout XML settings and other code sharing techniques.

For example, we want to ship a new Chart Property Editor, which will take a Razor file as input (with required graph layout and series settings). XAF Blazor will bind the underlying control to current View data automatically. For PDF Viewer and HTML Editor, we hope to implement seamless/codeless integrations, much like our Rich Text Property Editor (which can be bound to a string or byte array property).

EF Core Enhancements

Concurrency Control for EF Core

XAF WinForms/Blazor EFCore-based apps will support Optimistic Concurrency control (similar to existing XPO ORM functionality). It will support both object-level and field-level locking, as well as advanced collision resolution and data merging.

Clone Object Module for EF Core

XAF WinForms/Blazor EFCore-based apps will support the Clone command (to 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.

No breaking changes are expected for existing XPO-based projects when using the DevExpress Project Converter (to handle all naming-related changes automatically). See Also: T1276850 - Core - The DevExpress.ExpressApp.CloneObject.Xpo assembly and NuGet package have been renamed.

Easier Database Updates for EF Core

v25.1 will simplify 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 apply EF Core migrations to the database 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 will also get rid of the redundant DBUpdater tool for EF Core-based apps. EF Core developers will 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.

Simplified Connection Settings for EF Core and XPO

The Template Kit will include popular connection options like PostgreSQL, SQL Azure, MySQL, Oracle, and SQLite (instead of just Microsoft SQL Server previously). 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 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 v25.1, we will simplify boilerplate code required to connect to a secure Middle Tier API server in non XAF-powered WinForms/WPF apps (via XAF's Security System and EF Core).

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

Enhanced Filtering by Non-Persistent Fields for EF Core

FilterController (and other XAF APIs working with server-side criteria) will better process non-persistent business class properties in Client data access mode. Once non-persistent properties are detected in ListView criteria, we will fully process it on the client side.

Cross-Platform Enhancements

Outlook-Inspired Demo in the Installation

XAF's Outlook-Inspired Demo will make its way to our Unified Component Installer in our v25.1 release cycle. We will also implement additional functionality in this demo, including aforementioned EF Core enhancements and new built-in XAF Property/List Editors.

Built-in Property Editors: TagBox, Checked ComboBox, Progress Bar

XAF Blazor/WinForms v25.1 will include built-in Property Editors based on these components. They will support CRUD, Security System, common Application Model options (AllowEdit, AllowClear, etc.), DataSourceXXX attributes for filtering, ImmediatePostData, and more standard XAF features.

For example, TagBox and Checked ComboBox are two popular options to save space in detail forms for collection data (as an alternative to large data grids). Progress Bar in both list and detail forms can be used as an alternative to standard Integer Property Editors with additional validation rules.

XAF Blazor/WinForms v25.1 will also support the DataSourceXXX attributes for our Enumeration Property Editors. For example, you can filter your enumeration values with the DataSourceCriteria attribute and the following criteria: "Status != 0 and Status > 2", "Status In (0,1,2)", "Status != '@This.OtherSelectedStatus'", etc.

Project Template Enhancements

XAF Blazor + Middle Tier Security

Template Kit v25.1 will include a new project template where XAF Blazor is connected to the Middle Tier Security application server. Much like XAF WinForms, this configuration will help XAF developers deliver more secure solutions, because the web server will not have direct access to the application database.

This is important for certain customers where hosting the application database on the same machine with the web server (where an XAF Blazor app is running) is a no-go due to strict security requirements.

XAF Blazor + Electron.NET for Windows and macOS/Linux Desktop

The Template Kit will also include a new “hybrid” desktop app for Windows and macOS/Linux (powered by Electron.NET and XAF Blazor). An XAF Blazor app is wrapped inside a native “web view” container for the target OS and connected to our Middle Tier application server (or database directly, if allowed). When used, XAF developers can address both Windows and non-Windows support where WinForms and browser-based apps do not meet client needs.

For end-users, this hybrid desktop app will feel and behave (performance-wise) no differently than Microsoft Teams, Visual Studio Code, Outlook (new), and similar hybrid apps. Let me quote one of our customers who successfully used this approach:

I use XAF Blazor to have a desktop application for macOS indeed. It is an administrative application for one-person businesses. Because this application contains normally sensitive data, I don't want to host this data on servers where I am responsible for. So a good choice seems to run the application on a desktop. macOS users are growing in our country, so the Electron solution seems a good choice.

XAF Blazor and Web API Service + AntiForgery

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

Multi-Tenancy Enhancements

With XAF v25.1, our Multi-Tenancy module will allow you to store custom data in a shared/hosted database (for both EF Core and XPO ORM). This will be helpful when storing currency, tax, and other global application settings. For XAF developers, it should dramatically simplify code because it will no longer be necessary to set up a separate Object Space Provider for the shared database manually.

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

Web API Service Enhancements

Our Backend Web API Service will introduce the following highly-requested usability features:

OData "Deep Insert" for XPO/EF Core and "Deep Update" for EF Core;
Concurrency Control for both EF Core and XPO ORM (currently "last wins");
OData Batch Operations (aka "Batch Update" support).

Your Feedback Matters

Just another reminder that our Roadmap v25.1 (below), What's New v24.2 (vote), and other surveys give you the opportunity to communicate your needs/concerns and allow us to make more informed development decisions.

XAF v24.2 EAP — Passwordless Sign-ins and MFA, Calculated Fields and Soft Deletion in EF Core, Tabbed MDI and Performance Enhancements in Blazor

Dennis Garavsky (DevExpress) — Wed, 02 Oct 2024 08:03:00 Z

This post documents a few XAF-related features we expect to ship in early December and details what’s inside our Early Access Preview build (for additional information on what you can expect in December, please refer to our Year-End v2024.2 roadmap). As you will note below, XAF-related focus areas remain Blazor, Entity Framework Core and Security.

.NET Core / .NET Enhancements

.NET 8, .NET Framework 4.6.2, Visual Studio 2019 are minimally supported versions for DevExpress libraries moving forward

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.

Easier Upgrade to .NET from .NET Framework

Our Project Converter can now convert DevExpress assembly references in your solution or specific projects to corresponding DevExpress NuGet packages. By selecting the "Convert DevExpress assembly references to NuGet packages" option under Advanced settings, you can easily transition to NuGet-based project management.

To streamline the upgrade process, our Project Converter automatically creates backup (.bak) files for your CSPROJ and VBPROJ files. Once DevExpress assemblies are converted, complete the upgrade process by using the Microsoft .NET Upgrade Assistant (to migrate your application to the most recent version of .NET).

Documentation: Migrate a .NET Framework App to .NET | Choose Suitable NuGet Feed | Install NuGet Packages in IDE

.NET 9 Support

XAF UI and Web API Service will fully support NET 9 in November (v24.2.2+). If you are already using .NET 9 RC1, replace 8.0.0 with 9.0.0 in the Model Editor config file (C:\Program Files\DevExpress 24.2\Components\Tools\eXpressAppFrameworkNetCore\Model Editor\DevExpress.ExpressApp.Design.ModelEditorServer.NetCore.v24.2.runtimeconfig.json): See T1200937 - Core - Model Editor does not work with .NET 8 projects.

Cross-Platform Enhancements

Security Enhancements: Passkeys and MFA Support with Microsoft Entra ID, Google and Other Authentication Providers

As you may already know, both XAF UI (Blazor and WinForms) and our Web API Service offer a "1-click" solution to incorporate modern OAuth2 authentication providers with native Single Sign-On (SSO) (such as Microsoft Entra SSO), Multi-Factor Authentication (MFA), and other security features. This works for both EF Core and XPO ORM. For additional information in this regard, refer to Active Directory and OAuth2 Authentication Providers in ASP.NET Core Blazor Applications and related documents.

Passkeys uses your device lock (such as your fingerprint, face, pin or pattern) to sign in to your Microsoft, Google or other authentication provider accounts. For example, Microsoft Authenticator can be used to sign in to any Microsoft Entra ID account without using a password. Microsoft Authenticator uses key-based authentication to enable user credentials tied to a device (where the device uses a PIN or biometrics). Windows Hello for Business uses a similar technology.

With v24.2, XAF UI (Blazor and WinForms) and our Web API Service will support all Passkey-related usage scenarios. This includes restoring a forgotten password, temporarily blocking access to accounts, account recovery, face recognition login, PIN, fingerprint, OTP, QR codes, or various authenticator apps, using a Middle Tier Application Server or simpler configurations in WinForms, etc.

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 and Free Joins. 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, Blazor), v24.2 (the links to WinForms and Blazor EAP posts).

Performance Enhancements

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]).

Internally, we also used CriteriaCompiler instead of CriteriaEvaluator in 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. Optimizations are not yet finalized, but our complete implementation should be available as we near Beta 1 in November (v24.2.2+). In the meantime, you can check out a few screenshots from our labs (these changes are not yet included into this EAP):

Audit Trail Enhancements

XAF now automatically excludes all non-persistent properties from the audit trail in XPO-based applications. This enhancement can improve performance if 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: T1246233 - Audit - Non Persistent Properties are Excluded from the Audit Log (XPO).

Usability Enhancements

We added new extension methods to make it easier to create a new Object Space using XafApplication and IObjectSpaceFactory.

// v24.1.3 and earlier
var os = Application.CreateObjectSpace(typeof(Person));
// v24.1.5+ and v24.2+
var os = Application.CreateObjectSpace<Person>();

If you used IObjectSpaceFactory in ASP.NET Core apps (Web API Service controllers, custom Razor components, etc.), please consider the following minor breaking change in v24.2: T1254577 - INonSecuredObjectSpaceFactory and IObjectSpaceFactory classes were moved to the DevExpress.ExpressApp namespace.

Artificial Intelligence (AI)

XAF Blazor and XAF WinForms-powered apps automatically derive all AI-related features available in DevExpress components for each supported UI platforms. You can either access underlying UI controls and enable AI features as necessary (an example with Blazor Rich Text Editor) OR create custom XAF Property Editors / user controls/forms based on AI-powered DevExpress controls like the Chat control.

DevExpress AI-powered APIs allow you to integrate the following AI services into your DevExpress-powered applications:

OpenAI
Azure OpenAI
Ollama

AI services and DevExpress AI extensions (behaviors) follow a "bring your own key" approach. DevExpress does not provide a REST API or include built-in LLMs/SLMs. To use AI services, you need an active Azure/OpenAI subscription to obtain the necessary REST API endpoint, key, and model deployment name. This information must be provided at application startup to register AI clients and enable DevExpress AI-powered features in your applications.

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.

ASP.NET Core Blazor UI

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 instead of 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.

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");

Tabbed MDI Enhancements

Tabbed MDI is a multiple document interface (MDI) UI metaphor found in many modern applications (including your favorite Web browser or Microsoft Outlook Web). It is a robust interface that maximizes document 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.

Early Access and CTP builds are provided solely for early testing purposes and are not ready for production use. This build can be installed side by side with other major versions of DevExpress products. Please backup your project and other important data before installing Early Access and CTP builds. This EAP may not include all features/products we expect to ship in our v24.1 release cycle. As its name implies, the EAP offers an early preview of what we expect to ship in two months.

Your Feedback Matters!

We recommend that you test the new features outlined in this post within Visual Studio 2022 using our MainDemo.NET.EFCore or MainDemo.NET.XPO demo (located in the following folder: "c:\Users\Public\Documents\DevExpress Demos 24.2\Components\XAF\"). You can also test the EAP build against your project, but please remember that this build is not ready for production use. We will keep you posted about additional features we expect to ship in 2024 (see our Year-End v2024.2 roadmap) as we get closer to official release.

If you've had the opportunity to use the EAP build, please post your thoughts in our roadmap survey below OR create a Support Center ticket. We will happily follow up.

Thanks,
Dennis Garavsky
Principal Product Manager
dennis@devexpress.com

XAF (Cross-Platform .NET App UI & Web API Service) — Year-End Roadmap (v24.2)

Dennis Garavsky (DevExpress) — Sun, 21 Jul 2024 23:51:00 Z

UPDATE: What's New in XAF (v24.2) | June 2025 Roadmap (v25.1)

As always, thank you for choosing XAF. We appreciate your support. This blog post outlines some of our XAF-related development plans for the second half of 2024 (v24.2). Strategically, our goal is to focus on performance, overall stability/usability in this release cycle.

If you have not heard of XAF before, XAF is a .NET application framework that helps you build powerful Office-inspired line-of-business apps with DevExpress Blazor and WinForms UI components (using Entity Framework or XPO ORM). Feel free to review XAF demos and compare XAF with other software development methodologies here.

When new users try unique XAF Blazor features live in our XAF Blazor demo (especially Tabbed MDI or runtime layout customizations), they often ask whether it is a WinForms app (or if they are familiar with XAF, they cannot believe how much XAF Blazor apps and DevExpress Blazor Components have progressed over the last couple of years).

Core/Cross-Platform

Enhancements within this category (for example, performance or security) apply to XAF/WinForms UI, Web API Service, and to WebForms (.NET Framework).

.NET Core Enhancements

We will introduce .NET 9 support for XAF Blazor/WinForms UI v24.2 and our Web API Service v24.2 (after November 2024). We will also support the latest .NET 9 previews for v24.1 (for early adopters to test).
.NET 8, .NET Framework 4.6.2, Visual Studio 2019 will be minimally supported versions for DevExpress libraries moving forward (v24.2+). Learn more about this global change in the following announcement.
With v24.2, we will improve integration with Microsoft's .NET Upgrade Assistant Tool. This change will simplify migration from .NET Framework to .NET. We expect to offer predefined mappings for appropriate DevExpress packages.
We expect to support XAF project and item templates for VS Code and Rider (potentially) as part of the cross-platform DevExpress Template Gallery (our CLI-based templates will be used under the hood).

Source Code Builder Enhancements

We will simplify the steps needed to rebuild assemblies from source code in our v24.2 release cycle:

Our source builder tool will ship in the DevExpress Unified Component Installer.
Our source builder tool will be more stable (we added more internal tests for the rebuild process on our build farm) and will require fewer steps to initiate/complete source rebuild.
It will be easier to rebuild .NET Core/.NET projects (currently, it is a manual process) and generate corresponding NuGet packages (including localization packages).

EF Core ORM Enhancements

We will add EF Core 9 ORM support for XAF Blazor/WinForms UI and Web API Service.
We will introduce ServerView and InstantFeedbackView data access modes for ListView, at least at the core level (additional integration for XAF Blazor/WinForms UI may be pursued in future versions).
We will implement a simpler solution for server-side calculated fields in EF Core (aka XPO's PersistentAliasAttribute).
We will support soft deletion for EF Core (aka XPO's Deferred Deletion).

XPO ORM Enhancements

We will support the latest versions of database drivers/connectors for PostreSQL, Oracle, and My SQL (and SQL Server 2024, should it be released).
We will support DateOnly/TimeOnly in XPO connection providers for .NET apps (this enhancement will benefit XAF/Reporting/Dashboards and other products since XPO is at the core of data access code internally).

Security Enhancements

We will simplify the following user management tasks for XAF-powered Blazor apps: MFA, Forgot Password, and potentially Sign Up.
We will enhance our built-in Tenant Resolvers (a part of our Multi-Tenancy module) so they work more effectively with OAuth2 providers such as Google or Microsoft Entra ID (example).
We will enhance XAF Blazor and Web API Service project templates to enable angiforgery protection by default. Even though CSRF tokens aren't involved in the server-side Blazor circuit by default, our customers can add custom code to XAF Blazor apps where CSRF will make sense (for instance, complex client-side code, which can consume external web services).

Performance Enhancements

We will refactor our internal code to use CriteriaCompiler instead of ExpressionEvaluator by default (wherever possible). This should enhance performance in certain implementation scenarios (Security System, Object Space, etc).
We expect to modify default indices for Audit Trail business classes and enhance read performance for specific usage scenarios.
We expect to optimize Notifications Module performance when an app includes multiple scheduler appointments.

ASP.NET Core Blazor UI

We expect to release the following XAF Blazor UI features/capabilities in our v24.2 release cycle (December 2024).

List and Property Editor Enhancements

XAF Blazor UI will include a built-in TreeListEditor (powered by the DevExpress Blazor TreeList).
We will support storage of HTML-formatted documents within the Rich Text Property Editor (learn more).
We want to support DataSourceXXX attributes for Enumeration Property Editors (much like the attributes available for Lookup and Link List Views).

Error Handling Enhancements

We will extend XAF's Blazor error handling engine (to closely mirror XAF WinForms/WebForms counterparts): non-critical exceptions will not crash the entire app and redirect to an error page but will instead be isolated in regions or notification messages. We hope to leverage ASP.NET Error Boundaries to address our requirements.
We hope to output more useful error information to developers during debug/development (currently, it requires using web browser tools - F12).

Performance Enhancements

We will optimize page rendering for a variety of common Blazor-specific usage scenarios (logon form, grid, and main menu toolbar rendering, etc.).
We hope to optimize tab close operations when Tabbed MDI is enabled (to avoid execution of unnecessary logic when disposing off related Views).
We will support ServerView and InstantFeedbackView data access modes for ListView with EF Core, at least at the core level (additional integration for XAF Blazor UI and DxGridListEditor with EF Core and XPO may be pursued in future versions).

Usability Enhancements

We will introduce tab context menus (Close, Close All But This, Close All), middle-mouse click, and potentially other usability enhancements.
We will add VisibleInCustomizationForm or similar attributes in the Application Model to hide certain properties or fields from ListView and DetailView customization forms much easier (without the need for manual code-based solutions).
We hope to make it easier for end-users to add/remove tabs during DetailView layout customization at runtime (this is a quite complicated task, which we researched in the past, but we want to give it another try).

Deployment Enhancements

We will publish a few examples and demonstrate how .NET Aspire can simplify development/deployment of XAF Blazor and Web API Service-based apps, especially for non-Windows production environments.

Our ultimate goal is to fully automate manual steps documented in the following help topics: Deploy an ASP.NET Core Blazor Server Application to Azure App Service | Deploy an ASP.NET Core Blazor Server Application to Linux with Nginx.

And Much More in Blazor Components...

For even more enhancements in XAF Blazor UI, please check out Blazor — Year-End Roadmap (v24.2) - many of these component features (not all) will be available in XAF Blazor automatically.

Your Feedback Matters

Your response to the following questions will help us refine plans for our next major release:

If you have yet to review the features/capabilities introduced in our most recent major update (v24.1), please visit the following webpage and let us know what you think of this release by responding to our online XAF v24.1 survey.

Thanks,
Dennis Garavsky
Principal Product Manager
dennis@devexpress.com

XAF v24.1 EAP — Tabbed MDI, Batch Edit, Notifications, Customization Form and Accessibility for Blazor, EF Core 8 and Performance Boost for Middle Tier Server

Dennis Garavsky (DevExpress) — Thu, 18 Apr 2024 13:04:00 Z

As you may already know, we are a couple of months away from our next major update (v24.1). This post describes a few XAF-related features we expect to ship in early June and details what’s inside our Early Access Preview build (for additional information on what you can expect, refer to our June 2024.1 roadmap).

As you will see below, XAF key focus areas will continue to remain Blazor, Entity Framework Core, Security and .NET 8. One of XAF’s core development pillars is Low-Code/No-Code .NET application development (for Web, Desktop and APIs simultaneously). When time to market/efficiency matters (especially in today's world), XAF can help you deliver line-of-business apps in the shortest possible time using familiar RAD methodologies.

If you own an active Universal Subscription, feel free to download this Early Access Preview (EAP) build at your convenience. If you own an active DXperience Subscription and would like to learn more about our Cross-Platform .NET App UI (XAF) or Web API Service, you can explore the features described herein by logging onto the DevExpress Download Manager and installing this EAP build in trial mode. Once you do, please take a moment to tell us whether these new features address your business needs. Your feedback will help us fine-tune our implementation before official launch.

ASP.NET Core Blazor UI

Tabbed MDI Support

Tabbed MDI is enabled in XAF WinForms apps by default, and XAF Blazor will provide a similar user experience in v24.1. You can also customize Tabbed MDI in the Model Editor as follows:

Restore previously opened tabs between application runs (RestoreTabbedMdiLayout = True by default)
Refresh View data source on tab focus (RefreshViewOnTabFocus = False by default)
Display or hide tab images (ShowTabImage = True by default)
Display tabs at the top, bottom, or right of the main window (TabPosition = Top by default)

In addition, you can access the underlying tab control in code and configure it as needed using a Controller (in the SolutionName.Blazor project). For instance, you can load tabs on demand or simultaneously.

protected override void OnFrameAssigned() {
    base.OnFrameAssigned();
    Frame.TemplateChanged += Frame_TemplateChanged;
}
private void Frame_TemplateChanged(object sender, EventArgs e) {
    if(Frame.Template is ApplicationMdiWindowTemplate template) {
        template.TabsModel.RenderMode = DevExpress.Blazor.TabsRenderMode.AllTabs;
    }
}

Since our EAP v24.1 contains known issues with Tabbed MDI (fixed in our latest builds), we mostly ask that you to test this UI metaphor in your app for feedback purposes.

Add New Fields into the Customization Form of the Grid and Layout Controls at Runtime

XAF WinForms apps include an Object Model dialog. With it, end-users can search, tick or untick data model fields (including sub-fields and collections), which are not yet displayed in the grid or layout control (as part of the Column Chooser or Customization Form).

Much like Microsoft Office apps, this capability allows users to fully customize list and detail forms (based on the structure of a data model). Again, this is helpful when developers need to address changes to business requirements without redeployment. For more information, refer to Runtime Layout Customization in ASP.NET Core Blazor Applications.

XAF Blazor provides a similar experience for both ListView and DetailView in v24.1 (just remember this known issue). This feature removes the need for many UI customizations in the design-time Model Editor (inside Visual Studio) - something many of you love in XAF WinForms UI. Of course, you can also disable these runtime capabilities for end-users.

Notifications Module

XAF Blazor v24.1 supports our Notifications Module. The module allows you to display reminders for scheduler appointments or any custom objects (such as tasks). The detail form for a scheduler appointment/event will also allow you to configure reminders like those available in Microsoft Outlook. With the help of the Notifications Module, your app can display a popup window before appointment/event start times.

NOTE: our Notifications module does not have to be bound to the Scheduler module: it can display notifications that originate from anywhere. In the latter instance, your goal as a developer is to provide the notifications service with notification items and the service will process them as required.

Batch / Cell Edit in Grid List Editor

Batch Edit support officially ships in XAF Blazor v24.1 via a single option (InlineEditMode = Batch) - much like its XAF WebForms counterpart. At present (v23.2), XAF Blazor developers must manually enable this option (learn more).

Accessibility Enhancements and Keyboard Support

Currently, XAF (UI for ASP.NET Core Blazor, WinForms, and ASP.NET WebForms) ships with partial accessibility support mirroring those found in corresponding DevExpress UI controls across respective UI platforms:

DevExpress ASP.NET Core Blazor
DevExpress WinForms
DevExpress ASP.NET Web Forms
DevExpress DevExtreme (DevExtreme UI controls are used in XAF ASP.NET Core Blazor and ASP.NET Web Forms UI.)

XAF Blazor also ships with its own set of UI components/elements (like property editors and action containers). In v24.1, we extended accessibility support and improved keyboard support for all XAF Blazor UI elements (~20% of scenarios). XAF accessibility support will also level up automatically as soon as we enhance accessibility in DevExpress Blazor UI components throughout 2024.

Our Blazor Grid's keyboard navigation option also officially ships and is enabled by default in XAF Blazor. See also the "Keyboard Support" and "Keyboard Support Enhancements and New Tab Navigation" sections in Blazor — June 2024 Roadmap (v24.1).

And Much More for Blazor...

For even more enhancements in XAF Blazor UI, please check out Blazor Component Suite — Early Access Preview (v24.1) - many of these component features will be available in XAF Blazor automatically.

Cross-Platform Enhancements

Migration from Newtonsoft.Json to System.Text.Json

System.Text.Json library is now used to deserialize input parameters for Backend Web API Service endpoints.

For more information, refer to my other post .NET and .NET Framework — Migration from Newtonsoft.Json to System.Text.Json (v24.1) and this Breaking Change.

EF Core 8 Support

EF Core 8 support officially ships in v24.1 for XAF and associated Backend Web API Service. EF Core 8 is the latest production-ready version of Entity Framework.

While EF Core 8 offers numerous advantages over its predecessor (performance and customization included), it also introduced a series of breaking changes that we will need to address (for instance, DateOnly and TimeOnly support). To solicit feedback before official release, we intentionally added preview (CTP) support of EF Core 8 in v23.2.4+.

For more information about recent EF Core updates, refer to the following Microsoft document: What's New in EF Core 8 | EF Core 8 Breaking Changes | Performance Benchmarks for EF Core 8 vs XPO ORM.

Multi-Tenancy: Extend the Built-in Tenant Class with Custom Fields

You can now extend the standard Tenant class to associate additional data (for instance, module and feature license info) with tenants stored in the application’s Host Database. Of course, you can also access custom Tenant fields in code later (from a Controller or Application Builders). We also supported this for both EF Core and XPO ORM.

// MySolution.Module\BusinessObjects\CustomTenant.cs
// EF Core
using DevExpress.Persistent.BaseImpl.EF.MultiTenancy;

public class CustomTenant : Tenant {
    public virtual string CustomField { get; set; }
}
// MySolution.Blazor.Server/Startup.cs (MySolution.Win/Startup.cs)
builder.AddMultiTenancy()
    .WithCustomTenantType<CustomTenant>()
    //...

Documentation

Cascade Deletion for Aggregated One-to-Many Collections in EF Core

With v24.1, XAF's Solution Wizard includes `modelBuilder.SetOneToManyAssociationDeleteBehavior(DeleteBehavior.SetNull, DeleteBehavior.Cascade);` in the OnModelCreating method of EF Core-based apps. This code will configure DeleteBehavior.SetNull for non-aggregated One-to-Many associations and DeleteBehavior.Cascade for aggregated One-to-Many associations respectively. Previously, XAF's Aggregated attribute was not considered by EF Core as it was for XPO ORM (and there might be exceptions in certain ListView scenarios).

Documentation

Bypass Security Permission Checks for Internal Business Logic

In addition, it is now possible to call the new SetPropertyValueWithSecurityBypass method from within your BaseObject descendants to bypass security checks for certain protected properties in your internal application logic (custom base classes are also supported).

This capability is especially valuable to XAF developers when you wish to set service properties like CreatedBy, ModifiedBy, CreatedOn, UpdatedOn, etc. - our Audit Trail and Model Difference modules operate using a similar mechanism. The SetPropertyValueWithBypassSecurity method can freely set protected properties on behalf of a restricted/regular user in code much like an application administrator - without having to know admin credentials (like impersonation for service tasks).

    ApplicationUser GetCurrentUser() {
        return ObjectSpace.GetObjectByKey<ApplicationUser>(
            ObjectSpace.ServiceProvider.GetRequiredService<ISecurityStrategyBase>().UserId);
    }

    public override void OnSaving() {
        base.OnSaving();
        if (ObjectSpace.IsNewObject(this)) {
            SetPropertyValueWithSecurityBypass(nameof(CreatedBy), GetCurrentUser());
        }
        else {
            SetPropertyValueWithSecurityBypass(nameof(UpdatedBy), GetCurrentUser());
            SetPropertyValueWithSecurityBypass(nameof(UpdatedOn), DateTime.Now);
        }
    }

Enhanced Performance for Middle Tier Security for WinForms Apps

XAF WinForms with Middle Tier Security will execute much faster in v24.1. Two of our best engineers from the Core squad, Max and Pavel, boosted performance for both EF Core 8 and XPO ORM, as compared to v23.2 (XPO ORM results are even better - a 2.5x improvement). Folks have not finished relevant optimizations, so we will share final numbers close to the official release in June).

The graphs below show the current duration of batch of performance tests and also individual tests in 24.1 vs v23.2 for EF Core 8.

Along with associated performance enhancements, this was the last step before we could enable Middle Tier Security in XAF WinForms apps in the Solution Wizard by default. Hopefully, XAF developers will find these new capabilities sufficient to switch to Middle Tier Security as well.

Early Access and CTP builds are provided solely for early testing purposes and are not ready for production use. This build can be installed side by side with other major versions of DevExpress products. Please backup your project and other important data before installing Early Access and CTP builds. This EAP may not include all features/products we expect to ship in our v24.1 release cycle. As its name implies, the EAP offers an early preview of what we expect to ship in two months.

Your Feedback Matters!

We recommend that you test the new features outlined in this post within Visual Studio 2022 using our MainDemo.NET.EFCore or MainDemo.NET.XPO demo (from "c:\Users\Public\Documents\DevExpress Demos 24.1\Components\XAF\"). You can also test the EAP build with your real app, but please remember that this build is not ready for production code. We hope to keep you posted about remaining features from our June 2024.1 roadmap as we get closer to official release (set for June 2024).

We realize alpha/beta-testing is a time-consuming process and we are grateful to those who invest time with our EAP builds. Find the current implementation lacking flexibility? Feel we've overlooked a valuable usage scenario? Does our current implementation fail to address your business requirements?

Please post your thoughts in our roadmap survey below OR create a Support Center ticket. We will happily follow up and do what we can to extend the capabilities of our new products/features.

Thanks,
Dennis Garavsky
Principal Product Manager
dennis@devexpress.com

XAF — World Training Tour by Xari to Master DevExpress .NET Application Framework

Dennis Garavsky (DevExpress) — Sun, 24 Mar 2024 17:06:00 Z

Good news for those of you interested in DevExpress XAF training.

Microsoft and DevExpress MVPs, Jose Columbie of Xari.io and Joche Ojeda of BitFrameworks.com have organized a world training tour for DevExpress XAF (our Cross-Platform .NET App UI and Web API Service products).

For more information on Xari.io and their XAF training tour, visit: https://xari.io/xaftraining/xari-xaf-training-tour/

Get Started with XAF today if you want to build Office-like line-of-business (LOB) apps powered by Blazor, WinForms, or WebForms much faster than using traditional approaches. Check out XAF's demos in your DevExpress installation or online at https://demos.devexpress.com/xaf/blazordemo/. You can learn more about XAF benefits here, and our Considerations for Newcomers will help you understand whether this application framework is right for your business.

Thanks,
Dennis Garavsky
Principal Product Manager
dennis@devexpress.com

XAF v24.1 — June 2024 Roadmap (Cross-Platform .NET App UI & Web API Service)

Dennis Garavsky (DevExpress) — Tue, 06 Feb 2024 23:38:00 Z

UPDATE: What's New in XAF (v24.1) - please vote in the survey | Year-End Roadmap (v24.2)

---------

The following list outlines features/capabilities we expect ship for XAF’s Cross-Platform .NET App UI and the DevExpress .NET App Security & Web API Service (expected release date: June 2024). You can also test our Early Access Preview (EAP v24.1) live and share your feedback before June: XAF v24.1 EAP — Tabbed MDI, Batch Edit, Notifications, Customization Form and Accessibility for Blazor, EF Core 8 and Performance Boost for Middle Tier Server. We will outline plans for our second major release of this year (expected release date: Dec 2024) in July.

Before I detail our roadmap, please take a moment to review XAF's What's New v23.2 and please submit feedback using the related survey. What's New and roadmap survey feedback gives you the opportunity to communicate your needs/concerns and allows us to make more informed development decisions. As always, thanks to everyone who has already submitted feedback/suggestions.

The information contained within this blog post details our current/projected development plans. Please note that this information is being shared for INFORMATIONAL PURPOSES ONLY and does not represent a binding commitment on the part of Developer Express Inc. This blog post and the features/products listed within it are subject to change. You should not rely or use this information to help make a purchase decision about Developer Express Inc products.

ASP.NET Core Blazor UI

We expect to release the following XAF Blazor UI features/capabilities in our v24.1 release cycle (June 2024). As you will see below, key focus areas will continue to remain Security, Blazor, and EF Core.

Accessibility Enhancements and Keyboard Support

DevExpress ASP.NET Core Blazor
DevExpress WinForms
DevExpress ASP.NET Web Forms
DevExpress DevExtreme (DevExtreme UI controls are used in XAF ASP.NET Core Blazor and ASP.NET Web Forms UI.)

XAF Blazor also ships with its own set of UI components/elements that do not support accessibility and have limited keyboard support. XAF Blazor developers must manually customize built-in HTML markup via the ComponentModel.SetAttribute() method (for property editors and action containers) to add required ARIA attributes.

We expect to introduce accessibility-related enhancements for unsupported XAF Blazor components throughout 2024. More information on accessibility will be forthcoming as we get closer to our mid-year release.

Our Blazor Grid's keyboard navigation will also officially ship and be enabled by default. See also the "Keyboard Support" and "Keyboard Support Enhancements and New Tab Navigation" sections in Blazor — June 2024 Roadmap (v24.1).

Tabbed MDI Support

Tabbed MDI is enabled in XAF WinForms apps by default, and XAF Blazor will provide a similar user experience in v24.1 (hopefully with an EAP in v23.2).

Add New Fields into the Customization Form of the Grid and Layout Controls at Runtime

XAF WinForms apps include an Object Model dialog. With it, end-users can tick or untick data model fields (including sub-fields and collections), which are not yet displayed in the grid or layout control (as part of the Column Chooser or Customization Form).

XAF Blazor will provide a similar experience for both ListView and DetailView in v24.1 (hopefully with an EAP in v23.2).

Notifications Module

XAF Blazor v24.1 will support our Notifications Module. The module allows you to display reminders for scheduler appointments or any custom objects (such as tasks). The detail form for a scheduler appointment/event will also allow you to configure reminders like those available in Microsoft Outlook. With the help of the Notifications Module, your app can display a popup window before appointment/event start times.

Scheduler Module - Shared/Multiple Resources

If the underlying Blazor scheduler component (DxScheduler) supports multiple resources for a scheduler appointment/event in v24.1 (see the "Multiple Resources (Resource Sharing)" section in Blazor — June 2024 Roadmap (v24.1)), XAF Blazor Scheduler module will allow you to use shared resources as well. Currently, only a single resource is allowed in DxScheduler, and XAF displays a validation error message when you attempt to link multiple resources to an appointment.

Batch / Cell Edit in Grid List Editor

The underlying Blazor Grid component (DxGrid) used by XAF Blazor now includes batch and cell edit support (Online Demo). At present, XAF Blazor developers must manually enable this option (learn more). Batch Edit support will officially ship in XAF Blazor v24.1 via a single option (InlineEditMode = Batch) much like its XAF WebForms counterpart.

Best Fit in Grid List Editor

As you probably know, the underlying Blazor Grid used by XAF Blazor can automatically adjust column width to fit actual cell content (using the AutoFitColumnWidths method). We have not enabled this behavior in XAF Blazor by default, because of conflicting interests of various user groups:

Some of XAF Blazor users wanted to have a Best Fit item in the context menu to apply Best Fit.
Others did not like this behavior and wanted to specify column width in percentages (%) instead of pixels using the Model Editor.
And a handful of our customers wanted to specify minimal default column width (120px or so) and did not want to deal with column width whatsoever, preferring to optionally resize columns at runtime, when necessary.

If you want to improve current 'status quo' behavior in v24.1, we kindly ask you to voice your opinion in the comments for this Support Center ticket, and describe your expectations for each use-case scenario (both design-time and runtime ListView configuration). Feel free to share screenshots and specific/actionable information. Please avoid posting "+1" or generic information, because it will not help us develop consensus or create the best possible solution to fully address the needs of the majority position.

Export Data from Grid List Editor to Excel when DataAccessMode = Server

Our Blazor Components v24.1 (see their v24.1 roadmap separately) will support Excel export functionality for grids bound to server-side data (for both EF Core and XPO ORM). To export data to Excel, the DevExpress Blazor Grid will display a loading indicator and download all records from a data source.

Simplified Creation of Custom Blazor Property and List Editors

Currently, XAF Blazor developers must create intermediate Component Adapter, Renderer and other boilerplate classes. In v24.1, we want to reduce boilerplate code for many popular scenarios, and make it possible to create custom Property Editors much like XAF WinForms. Our newest Outlook Inspired Demo app contains many custom Property and List Editors, and it will be a good source of UX validation/comparison between v23.2 and v24.1 - please stay tuned.

Migration to the Native Blazor Report Viewer

In v24.1, XAF's Blazor Reporting Module will migrate from a JavaScript-based Report Viewer (DxDocumentViewer) to the native Report Viewer for Blazor Server apps (DxReportViewer). We are kind of fixing a technical debt here, because the native report viewer was introduced in 2021, and has a number of benefits for XAF Blazor developers:

Support of Size Modes and all Blazor themes
Easier customization without JS using pure C#
Improved performance: Native implementation reduces load time and increases page navigation speed when compared to JavaScript wrapper based reporting tools.

And Much More...

For even more enhancements in XAF Blazor UI, please check out Blazor — June 2024 Roadmap (v24.1) - many of these component features will be available in XAF Blazor automatically.

Security Enhancements

Single Sign-On (SSO) Support

Today, modern XAF Blazor and WinForms apps are integrated with many external systems within organizations. For instance, if an organization uses Microsoft 365, XAF apps are often available at https://myapps.microsoft.com/ among many other apps within this organization. Since XAF Blazor and WinForms .NET 6+ apps (both XPO and EF Core-based) support Microsoft Entra ID and other OAuth2 providers, organizations want/prefer XAF apps to share the same login details or authentication cookies with existing systems/services such as Microsoft Entra Single Sign-On (SSO). In v24.1, XAF apps will support SSO natively.

Said differently, organizations require the following: When a user is already authenticated within the organization (for instance, using Microsoft 365), XAF apps must seamlessly work with SSO. Currently, XAF developers have to implement custom solutions to modify XAF’s login form and authentication behavior to support SSO. Important SSO scenarios include, but are not limited to the following:

If a user is NOT logged in within the organization, then XAF apps display a standard OAuth2/SSO provider logon form (just like Teams, Word or Outlook normally does for Microsoft 365). If a user was forced to sign out by administrators, then XAF apps should display the standard logon form as well.
If a user is logged in within the organization (it can be another non-XAF app), then no XAF login form is displayed for the user and focus moves directly to the XAF app UI (by a link from an organization's `Apps dashboard` or via other methods). The logon procedure in an XAF app proceeds automatically behind the scenes (via API calls). XAF users should NOT be forced to explicitly press the “Login with Microsoft” in this instance, because SSO will "just work" as expected.
If a user within the organization needs to undergo additional security checks after a user is already logged on (for instance, reconfirm MFA information via the phone after 30-60 days), then XAF apps must provide a clear and understandable standard OAuth2 provider UI and disallow any operations within XAF UI. For instance, Teams, Word or Outlook display modal dialogs to reconfirm your login details, before users can access and use these Microsoft 365 apps again.

Support of ASP.NET Core Identity and Other External Permission Providers and Storages

With v24.1, you can enable standard ASP.NET Core Identity framework capabilities in your XAF Blazor and WinForms apps powered by .NET 6+ and Entity Framework Core. This includes seamless integration of Microsoft.AspNetCore.Identity.EntityFrameworkCore and database-specific Identity packages like Microsoft.EntityFrameworkCore.SqlServer.

If you enable this opt-in feature in XAF’s Solution Wizard, your XAF project will generate `public class ApplicationUser : IdentityUser { /*...* /}` along with a preconfigured DbContext - both are integrated with XAF’s security system for authentication and authorization (role-based access control or RBAC). The link between XAF’s RBAC (type, record, and field-level permissions) is established through the generic IdentityRole and other EF Core data model classes, which are parts of the Identity data model. This Identity data model is mapped to the underlying databases with EF Core.

In addition to the Identity model and database storage, XAF customers will experience the following benefits:

Automatically access all standard Identity features such as Single Sign On (SSO), endpoints to register new users (example), restore password, and other Microsoft implementations (or future .NET implementations).
XAF-specific permissions are serialized as JSON, and are stored in IdentityRole-related tables. For advanced scenarios, XAF developers can implement a custom permission provider, for instance, to synchronize user permissions and roles with an external service instead of the Identity database (technically you need to pass JSON between your XAF app and external endpoints).
The amount of security configuration code in your XAF project will also be minimized: builder.Services.AddIdentityCore<ApplicationUser>() .AddEntityFrameworkStores<AppDbContext>() .AddApiEndpoints();
If you already have external projects, which used EF Core and Identity, then XAF’s integration will become much easier as well. It will be easier to add developers to an XAF-powered project as well, because EF Core and ASP.NET Core Identity frameworks are used by millions of .NET developers.
XAF will continue generating its standard logon and CRUD UI screens for Identity users and roles, and allow you to edit XAF’s permissions for these roles.
You can also refer to your ApplicationUser class in other data models (for instance, to implement the CreatedBy or ModifiedBy properties). Standard criteria functions such as CurrentUserId, IsUserInRole and others will function as well.

Middle Tier Security for WinForms Apps: Multi-Tenancy and OAuth2 Support

In v24.1, XAF WinForms apps (.NET 6+) with Middle Tier Security will natively support OAuth2 providers and Multi-Tenancy.

As we described in our Security Considerations document, Windows desktop apps can better meet enterprise security standards with our Middle Tier application server. With our solution, EF Core or XPO developers can retain their standard DbContext or Session and initiate remote connections to a data store from any .NET client (like XAF WinForms or non-XAF apps). This capability is critical within certain environments/business apps (those that cannot maintain direct database connections because of security considerations).

I want to stress an important point: Non-XAF EF Core or XPO developers can benefit from our Middle Tier application server and preserve DbContext or Session with their entity data model (learn more). This is especially critical for many desktop .NET developers (WinForms, WPF, WinUI, etc.), who are now required to meet higher security standards. In a nutshell, these developers need to either retrofit/modernize their "fat clients" for Windows (#1) or redo everything from scratch using modern Web technologies and Cloud services (#2). Our Middle Tier Security allows you to choose the "easier" and potentially more reliable route (#1), and to "replace" direct database connections with middleware. Review the following code snippet for more information in this regard:

var httpRemoteRepository = new HttpRemoteRepository(httpClient, typeof(EFCoreDbContext).FullName);
var optionsBuilder = new DbContextOptionsBuilder<EFCoreDbContext>();
optionsBuilder.UseMiddleTier(opt =>
    opt.UseRemoteRepository(httpRemoteRepository));
optionsBuilder.UseChangeTrackingProxies();
optionsBuilder.UseLazyLoadingProxies();
var dbContextOptions = optionsBuilder.Options;
var dbContext = new EFCoreDbContext(dbContextOptions);
var users = dbContext.Employees.ToList();

Middle Tier Security for WinForms Apps: Enhanced Performance and Usability

XAF WinForms with Middle Tier Security will execute much faster in v24.1 (we will share exact numbers close to the official release in June).

In addition, it will now be possible to call the new SetPropertyValueWithBypassSecurity method from within your BaseObject descendants to bypass security checks for certain protected properties in your internal application logic (custom base classes are also supported).

public override void OnSaving() {
    if (ObjectSpace.IsNewObject(this)) {
        SetPropertyValueWithBypassSecurity(nameof(CreatedBy), GetCurrentUser());
    }
    else {
        SetPropertyValueWithBypassSecurity(nameof(UpdatedBy), GetCurrentUser());
        SetPropertyValueWithBypassSecurity(nameof(UpdatedOn), DateTime.Now);
    }
    if (!IsRunningOnMiddleTierServer()) {
        // ...
    }
}

As you probably know, this is a long-requested option for many XAFers - an option that prevented full migration from Integrated Mode to Middle Tier Security (because CreateNonsecuredObjectSpace and other workarounds were inconvenient). The SetPropertyValueWithBypassSecurity also includes certain limitations like calling this method is only supported from inside BaseObject.OnSaving (for the best security) or the bypassed property cannot update other protected properties internally. We are of the opinion that this new option will cover 80% of popular use-cases. Along with associated performance enhancements, this was the last step before we could enable Middle Tier Security in XAF WinForms apps in the Solution Wizard by default. Hopefully, XAF developers will find these new capabilities sufficient to switch to Middle Tier Security as well.

Cross-Platform Enhancements

Before I move onto cross-platform enhancements, a quick reminder…XAF is fully extendable framework/constructor. You can incorporate Blazor and DevExtreme UI components, and by extension, customize XAF’s default UI today: Blazor UI (FAQ) | More customization tips.

Command Line Interface (CLI) Solution Wizard Templates

XAF v24.1 will allow you to use the .NET command line interface (CLI) or the `dotnet` tool to quickly create XAF Blazor and WinForms apps from the console (without using XAF's Solution Wizard). This will be similar to the DevExpress Reports implementation: Use .NET CLI Templates.

This capability will be valuable for XAF developers using Microsoft Visual Studio Code (VS Code) or JetBrains Rider in both Windows and non-Windows development environments (like Linux or MacOS). Previously, these users had to first create XAF projects in Visual Studio for Windows using the Solution Wizard.

Since you will be able to create and modify DevExpress Reports in VS Code on macOS and Linux, the only missing puzzle for non-Windows XAF development is a convenient way to modify the Application Model. While the Model Editor is available only in Visual Studio for Windows, plenty of code-based options exist and are actively used by some XAF developers. Notwithstanding the visual capabilities of the Model Editor, XAF Blazor UI also includes great runtime customization capabilities much like in XAF WinForms. These capabilities address many popular Application Model customization scenarios. For more information, refer to the following post: XAF (Blazor UI) 2023 Highlights — 5 Unique Web Features Designed to Rival Windows Desktop Solutions.

Automatic Code Error Diagnostics

We expect to add 5-10 new automatic Code Diagnostics. We hope this will save you time in Visual Studio or validate build quality using internal CI/CD workflows. If you have not yet enabled these pre-built code & project error diagnostics, we strongly recommend that you do so for your .NET 6+ projects.

Web API Service for XAF & Non-XAF UI Clients (Powered by EF Core & XPO ORM)

In v24.1, our Web API Service will support Multi-Tenancy for both EF Core and XPO ORM.

As you may already know, we officially released our Backend Web API Service in mid-2022 and have enhanced its capabilities and docs ever since. Our Web API Service has both FREE (basic CRUD) and paid features (such as reporting, audit trail, validation, file attachments, localization, etc). We also distribute many demo applications illustrating the use of free and paid APIs with .NET MAUI, Blazor WebAssembly, JavaScript and even more (by paid features, I simply mean you must own a DevExpress Universal Subscription license).

To learn more about our Web API Service and determine whether it can be of value within your organization, please review the following blog post: Common Questions about the New DevExpress Web API Service (powered by Entity Framework and XPO ORM).

Entity Framework Core 8

EF Core 8 support will officially ship in v24.1 for XAF and associated Backend Web API Service. EF Core 8 is the latest version of Entity Framework.

While EF Core 8 offers numerous advantages over its predecessor (performance and customization included), it also introduced a series of breaking changes that we will need to address. To solicit feedback before official release in 4 months, we intentionally added preview (CTP) support of EF Core 8 in v23.2.4+.

For more information about recent EF Core updates, refer to the following Microsoft document: What's New in EF Core 8 | EF Core 8 Breaking Changes | Performance Benchmarks for EF Core 8 vs XPO ORM.

Support of New .NET DateOnly and TimeOnly Types for Entity Framework Core 8 and Blazor/WinForms UI

As you probably read in the EF Core 8 breaking changes above, SQL Server date and time now scaffold to .NET DateOnly and TimeOnly. XAF Blazor and WinForms apps for .NET 6+ will update associated Date and Time Property Editors to support the new .NET types accordingly. The underlying Blazor and WinForms grid components will support operations with DateOnly/TimeOnly (sorting, grouping, filtering, etc.) - as will Criteria Language, Server Mode, and other underlying data access components for EF Core.

Cascade Deletion for Aggregated One-to-Many Collections in EF Core

With v24.1, XAF's Solution Wizard will include `modelBuilder.SetOneToManyAssociationDeleteBehavior(DeleteBehavior.SetNull, DeleteBehavior.Cascade);` in the OnModelCreating method of EF Core-based apps. This code will configure DeleteBehavior.SetNull for non-aggregated One-to-Many associations and DeleteBehavior.Cascade for aggregated One-to-Many associations respectively. Previously, XAF's Aggregated attribute was not considered by EF Core as it was for XPO ORM (and there might be exceptions in certain ListView scenarios).

Your Feedback Matters

Just another reminder that our Roadmap v24.1, What's New v23.2, and other surveys give you the opportunity to communicate your needs/concerns and allow us to make more informed development decisions.

Thanks,
Dennis Garavsky
Principal Product Manager
dennis@devexpress.com

XAF — Entity Framework Core 8 Support and Updated Performance Benchmarks for .NET 8

Dennis Garavsky (DevExpress) — Fri, 02 Feb 2024 13:56:00 Z

Great news for customers using Entity Framework Core (EF Core): XAF v23.2.4+ and associated Backend Web API Service include preview (CTP) support of EF Core 8. We intentionally added support for EF Core 8 in v23.2.4+ to solicit feedback before official release in 4 months (EF Core 8 support will officially ship in v24.1).

We also updated our performance benchmarks for EF Core 8 vs XPO ORM. Kudos to Microsoft with .NET 8 - noticeable speed enhancements as compared to .NET 6-7 (and older EF Core versions). For more information about recent EF Core updates, refer to the following Microsoft document: What's New in EF Core 8.

Getting Started with XAF

If you have not heard of XAF before, XAF is a .NET application framework that helps you build powerful Office-inspired line-of-business apps with DevExpress Blazor and WinForms UI components (using Entity Framework or XPO ORM). We often call XAF the "Fastest App UI Builder for EF Core ORM", because it allows you to progress from a C# entity class to powerful Web, Desktop, and Mobile UI forms in minutes using its integrated Solution Wizard and built-in modules such as Validation, Reporting, Scheduler, Office, Dashboards, etc.

For complex enterprise-level usage scenarios, XAF ships the Multi-Tenancy, Audit Trail, and Security System modules. Built-in security features include:

Role-based access control (RBAC) including type, record, and field-level permissions (learn more). You can manage users and roles at runtime using XAF's administrative UI/ portal for Blazor, WinForms, and WebForms (or in code manually).
Flexible authentication strategies including Microsoft Entra ID (former Azure Active Directory), Google, and other OAuth2 providers (learn more). The XAF login form automatically renders UI controls based on authentication settings you specified in the Solution Wizard (or in code manually).
Middle Tier application server for modern desktop, web and mobile apps (learn more). EF Core developers can retain their standard DbContext and initiate remote connections to a data store from any .NET client (like XAF WinForms or even non-XAF apps). This capability is critical within certain environments/business apps (those that cannot maintain direct database connections because of security considerations).

Thanks,
Dennis Garavsky
Principal Product Manager
dennis@devexpress.com