XAF Team Blog

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

Dennis Garavsky (DevExpress) — Mon, 17 Feb 2025 09:31:00 GMT

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 2025 (v25.1, set for release in June 2025).

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

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.

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

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

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 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 15:03:00 GMT

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.

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.

.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) — Mon, 22 Jul 2024 06:51:00 GMT

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 20:04:00 GMT

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.

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) — Mon, 25 Mar 2024 00:06:00 GMT

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) — Wed, 07 Feb 2024 07:38:00 GMT

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 21:56:00 GMT

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

XAF Blazor & WinForms UI — .NET 8, Built-in Security and Multi-Tenancy Support, Integration of Custom Components, UI Customizations (v23.2)

Dennis Garavsky (DevExpress) — Fri, 19 Jan 2024 10:08:00 GMT

As you probably know, our WinForms products ship with a custom Outlook-inspired app. You can review this app using the DevExpress Demo Center v23.2 (under the WinForms category), if you download and run our Unified Component Installer (Trial/Paid). The app features many of our WinForms control, including but not limited to reports, charts, pivot grids, maps, rich text editors, data grids with master-detail and layout views, etc.

Until recently, we have not offered a showcase demo of a similar complexity for XAF, our Cross-Platform .NET App UI framework.

XAF's Outlook-inspired Demo App

For our v23.2 release, we replicated our WinForms Outlook-inspired demo app using XAF's WinForms UI (view it on GitHub). We also added a Blazor counterpart to the XAF WinForms demo (replicating the same screens using our Blazor and JavaScript (DevExtreme) UI components). If you read my recent post (XAF (Blazor UI) 2023 Highlights — 5 Unique Web Features Designed to Rival Windows Desktop Solutions), you'll note that XAF Blazor and its underlying components are production-ready and can deliver many of the same capabilities as XAF WinForms for typical line-of-business apps.

In addition to replicating functionality found in its WinForms only counterpart, XAF's new Outlook-inspired demo includes the following unique features/capabilities:

1. Built-in Multi-Tenancy support for complex enterprise-level usage scenarios (XAF's Multi-Tenancy module was first introduced in our v23.2 release cycle).

2. Built-in security features, including but not limited to role-based access control (RBAC) with flexible authentication strategies including type, record, and field-level permissions (learn more). A quick aside: We wanted to use our Middle Tier application server (powered by EF Core) for the WinForms portion of the demo, but decided to skip it for the sake of simplicity. Such enterprise-level features are critical in modern desktop apps, so we will likely incorporate Middle Tier Security in this demo for v24.1.

3. Comprehensive set of runtime UI customization options (for developers and end-users alike): XAF (both Blazor and WinForms UI) allows you to address changes to business requirements without redeployment. Want to rearrange grid columns/detail form editors, or create/remove layout groups/tabs directly in your web browser? Customizations such as these are straightforward for XAF-powered apps (learn more).

Custom UI Components: XAF's Inherent Extensibility

The myth that XAF is "inflexible" is just that - a myth. Thanks to thousands of XAF customers who have delivered thousands of production apps of varying complexity over the last 15 years, we know that XAF is more than capable of addressing complex enterprise usage scenarios (for proof, check out customer case-studies, XAF landing page for newcomers, hundreds of user reviews on G2, Visual Studio marketplace, DevExpress.com itself; thousands of Support Center tickets, or even from living legends dominating their home markets with XAF-based apps like https://www.prakom.net/. Our new XAF demo is another example that shatters this myth.

To help XAF newcomers learn common UI customization techniques faster, we also published a detailed readme on how to accomplish the following:

Create custom Property and List Editors, or other View Item types/templates (documentation).
Build custom Razor components from scratch or integrate standard and third-party Blazor and JavaScript components;
Organize your solution structure/folders for Blazor and WinForms at the same time and share/reuse code between platforms.

Initially, we also wanted to describe how to write unit, functional (e2e) and integration tests for both UI platforms and run them on Azure (critical for many enterprise-level teams/apps). This would have increased the length of the readme by more than 10 pages, so we skipped this for now. We may still describe this topic in detail later, should user demand exist - please let us know in the DevExpress Support Center. In the meantime, explore our tests in this demo folder at your convenience.

This GitHub repro illustrates (through code examples) how to implement certain features, which may be temporarily missing in our Blazor Components or XAF Blazor UI itself. For instance, want fancy maps, grid card views or tricky chart integrations, which may not make it into a standard delivery due to limited use by all XAF customers? Simple - follow our lead, just copy or learn from code by example.

Your Feedback Matters!

As always, you are more than welcome to share your feedback about XAF's Multi-Tenancy module, Blazor/WinForms UI, EF Core, Middle Tier Security, Web API Service, and more via the DevExpress Support Center or the survey below.

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

XAF (Blazor UI) 2023 Highlights — 5 Unique Web Features Designed to Rival Windows Desktop Solutions

Dennis Garavsky (DevExpress) — Thu, 28 Dec 2023 02:08:00 GMT

In this last post of 2023, I want to highlight a few Cross-Platform .NET App UI (XAF)-related features we added or improved in 2023. When new users view screenshots of these unique XAF Blazor features or try them live in our XAF Blazor demo, they often ask whether it is a WinForms app (or if they are familiar with XAF, they cannot believe how much XAF Blazor apps have progressed over the last couple of years).

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 Audit Trail, Validation, Reporting, Scheduler, or Security System.

Unique Feature #1: End-User/Runtime Layout Customization within Detail Forms

With this UI/UX option, XAF Blazor users can create and manage their own UI directly in the Web browser. UI customization (for both developers and users) can be a time saver - customizable Web apps can address changing business requirements without the need for redeployment. As you would expect, you can disable these advanced customization capabilities for specific users. Use the CustomizationEnabled property in the Model Editor or in code.

This is a XAF-specific feature, which is unavailable in DevExpress Blazor UI components by default. This feature mirrors functionality found in the DevExpress WinForms Layout Control.

Documentation

Unique Feature #2: End-User/Runtime Grid Customization in List Forms

XAF Blazor ships with a Context menu for grid headers and rows (just like its WinForms/WebForms counterparts). Column Chooser, Hide Column, Group by Column, Show Auto Filter Row, Filter Editor, or Reset View Settings commands are available within the menu. Grid rows ship with New, Clone, Delete, Export To, and other menu items.

This is a XAF-specific feature, which is unavailable in DevExpress Blazor Components by default (you can implement this functionality using DxContextMenu). This feature mirrors functionality found in the DevExpress WinForms Grid Control.

Documentation Breaking Change in v23.2

Unique Feature #3: Advanced Filter Builder to Shape Data within List and Detail Forms

XAF integrates a JavaScript-based Data Filtering UI (Filter Criteria Editor), first introduced in our Web Reporting and BI Dashboard products. This filter builder supports popular criteria language options based on reference, collection, and scalar/value type properties (such as strings, numbers, etc). Filter UI helps address advanced usage scenarios and augments our Blazor Grid's Auto Filter Row, Find Panel, or Column Header Filter options. XAF's Filter Builder also helps application administrators/developers configure field and record-level security permissions for user roles (as part of XAF's Security System and its account management UI).

This is a XAF-specific feature, which is unavailable in DevExpress Blazor Components (you cannot implement this functionality on your own easily). This feature mirrors functionality found in the DevExpress WinForms Filter Control.

Documentation

Unique Feature #4: Master-Detail Mode Splitter for List Forms

In XAF Blazor, end-users can use this splitter to resize side-by-side master and detail views much like the UI metaphor used in Microsoft Outlook (compact view). Splitter position is saved in the Application Model (end-user settings are stored in the database by default when the Security System is enabled).

This is a XAF-specific feature, which is unavailable in DevExpress Blazor UI components by default. This feature mirrors functionality found in the DevExpress WinForms Layout Control.

Documentation

Unique Feature #5: Built-in OAuth2 Authentication Provider Support (Microsoft, Google, etc.)

XAF Blazor as well as its backend Web API Service support various OAuth2 authentication providers: Windows, Microsoft Entra ID (former Azure Active Directory), Google, GitHub, and others. The XAF Blazor login form automatically renders UI controls based on authentication settings you specified in the Solution Wizard (or in code manually). XAF Blazor also includes "Brute Force" attack protection designed to limit unauthorized login attempts.

This is a XAF-specific feature, which is unavailable in DevExpress Blazor Components by default.

Documentation General Security Considerations

Expected Enhancements for 2024: Bringing XAF Blazor Closer to Windows Desktop Apps

In addition to expected enhancements in 2024 like complete Notifications Module or EF Core 8 support, batch/cell-editing within DxGridListEditor, accessibility (a11y) and performance enhancements, I wanted to share a few bonus features, which are already in the works.

Tabbed MDI Support

Tabbed MDI is a type of multiple document interface (MDI) found in most modern applications (for instance, your favorite Web browser or Microsoft Outlook Web). It is a robust interface that maximizes document screen real estate usage, especially when you have dozens of documents, email messages, etc.

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

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

Much like in Microsoft Office apps, this capability allows users to fully customize list and detail forms (based on the structure of your data model). Again, this is helpful when developers need to address changes to business requirements without redeployment.

XAF Blazor will provide a similar experience in v24.1 (hopefully with a EAP in v23.2).

Your Feedback Matters!

Please, review the description of new XAF-related features in What's New v23.2 and leave your feedback at the end of the section: Go to the survey now.

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

XAF (WinForms UI) — Case Study by ASTGD: A Complete Medical Management System

Dennis Garavsky (DevExpress) — Thu, 28 Dec 2023 00:00:00 GMT

Meet Minhazul Islam, a managing director of ASTGD (an IT company in Bangladesh) who has been using our Cross-Platform .NET App UI (XAF) since 2013.

We recently published a case study about their hospital management system (MediManage Pro) powered by XAF - DevExpress WinForms UI and Reporting components. Here is how ASTGD developers described their product:

MediManage Pro is a comprehensive medical management system designed to automate the operations of hospitals, clinics, or diagnostic centers. This fully customizable enterprise solution offers a wide range of functionalities to streamline various aspects of healthcare management. Barind Medical College & Hospital Ltd. (bmc.edu.bd), a renowned medical college was looking for a complete software solution that can serve the needs of healthcare facilities looking to improve their administrative and operational efficiency. ASTGD proposed a custom solution and later ASTGD built this complete hospital management system.

And here’s what Minhazul Islam said about XAF's primary benefits:

The project timeline was very limited compared to its vastness. ASTGD needed a solution that can provide cutting edge error free solution in less time. DevExpress XAF is a low code application framework that is also ORM based and provides some crucial built in modules that comes handy while developing this kind of applications. Despite all these ASTGD chose XAF for two main reasons:
- XAF provides automated UI and model editor provides capability to easily customize UI.
- XAF comes with built in security modules that provides roles and user-based permission and it is easy to implement/modify/customize.

Read the full article to learn why ASTGD chose XAF for Windows project development and what they liked about our tools.

Do You Have a Story to Share?

We'd love to publish your story on our website. It doesn’t matter if the project is big or small, or which DevExpress tools you used. Fill out this simple case study form and email us at clientservices@devexpress.com.

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

XAF Team Blog

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

Blazor UI Enhancements

Fluent Theme and Ribbon UI Support

Accessibility Enhancements

Grid List Editor Enhancements

ToolTip Attribute Enhancements

Simplified Chart, HTML Editor, and PDF Viewer Integration

EF Core Enhancements

Concurrency Control for EF Core

Clone Object Module for EF Core

Easier Database Updates for EF Core

Simplified Connection Settings for EF Core

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

Enhanced Filtering by Non-Persistent Fields for EF Core

Cross-Platform Enhancements

Outlook-Inspired Demo in the Installation

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

Project Template Enhancements

XAF Blazor + Middle Tier Security

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

XAF Blazor and Web API Service + AntiForgery

Multi-Tenancy Enhancements

Web API Service Enhancements

Your Feedback Matters

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

.NET Core / .NET Enhancements

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

Easier Upgrade to .NET from .NET Framework

.NET 9 Support

Cross-Platform Enhancements

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

EF Core Calculated Fields

EF Core Soft Deletion

EF Core Filtering Capabilities Are Now on Par with XPO ORM

XPO DateOnly/TimeOnly Support

Performance Enhancements

Audit Trail Enhancements

Usability Enhancements

Artificial Intelligence (AI)

ASP.NET Core Blazor UI

HTML Markup Support within the Rich Text Property Editor

Default Caption or Image in Action Container with Drop-Down Menu

Tabbed MDI Enhancements

Your Feedback Matters!

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

Core/Cross-Platform

.NET Core Enhancements

Source Code Builder Enhancements

EF Core ORM Enhancements

XPO ORM Enhancements

Security Enhancements

Performance Enhancements

ASP.NET Core Blazor UI

List and Property Editor Enhancements

Error Handling Enhancements

Performance Enhancements

Usability Enhancements

And Much More in Blazor Components...

Your Feedback Matters

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

ASP.NET Core Blazor UI

Tabbed MDI Support

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

Notifications Module

Batch / Cell Edit in Grid List Editor

Accessibility Enhancements and Keyboard Support

And Much More for Blazor...

Cross-Platform Enhancements

Migration from Newtonsoft.Json to System.Text.Json

EF Core 8 Support

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

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

Bypass Security Permission Checks for Internal Business Logic

Enhanced Performance for Middle Tier Security for WinForms Apps

Your Feedback Matters!

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

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

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

ASP.NET Core Blazor UI