XAF Team Blog

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

Dennis Garavsky (DevExpress) — Mon, 24 Aug 2026 06:00:00 Z

Thank you for your continued support and for sharing your XAF development requirements with us via product surveys, Support Center tickets, email, and social media engagements. This post outlines features and capabilities we expect to ship in our year-end release (v26.2 - Dec 2026).

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.

Security and Dependency Updates

.NET 11 Support

DevExpress XAF Blazor/WinForms, Web API Service, and XPO ORM library will support .NET 11 (both v26.1 and v26.2) following Microsoft's official release.

Minimum Supported .NET and Visual Studio Versions

As you may know, .NET 8 and .NET 9 will reach end of support on November 10, 2026. We will therefore raise our minimum supported .NET version to .NET 10 once we release v26.2 in December. Visual Studio 2026 will be the minimum supported IDE version when XAF Blazor/WinForms/Web API Service v26.2 ships.

Separate NuGet Packages for Different .NET Versions (.NET 10, .NET 11, etc.)

Today, third-party dependencies are automatically patched after a detected vulnerability (for example, a vulnerability in System.Security.Cryptography.Xml) only for the minimally supported .NET version (today it's .NET 8). Today (with v26.1, v25.2, v25.1, v24.2), manual version pinning (Solutions #1 or #2 from this article) may still be required for .NET 9/10-based projects depending on their exact TFM and project SDK. We will provide .NET-specific dependency groups in DevExpress NuGet packages, which will simplify use of v26.2.

Entity Framework Core 11 for Data Access

v26.2 will add official support for the most recent version of Entity Framework (EF Core 11) to our XAF Blazor/WinForms UI and Web API Service. We will also update our performance benchmarks - comparing EF Core 11 with XPO.

While EF Core 11 introduces performance and customization improvements, it also includes breaking changes that require updates on our side. Not all EF Core database providers offer compatible NuGet packages (for instance, we had to remove Pomelo.EntityFrameworkCore.MySql support in v26.1.5+).

SBOMs and CRA Readiness

If you deliver software in the EU, the Cyber Resilience Act (CRA) will require a Software Bill of Materials (SBOM – an inventory of every component inside your solution) as part of your conformity documentation. The CRA and its associated regulatory regime will go into effect on December 2027. Each software application/solution manufacturer must fulfil SBOM-related obligations. DevExpress-authored SBOMs will help customers document/inventory DevExpress libraries used within a DevExpress-powered app.

Most dependency scanners and SBOM generation tools read what a NuGet package declares (its dependencies on other NuGet packages) and stop there, which leaves two gaps we fill:

Components embedded inside a package. Some DevExpress NuGet packages bundle fonts and third-party JavaScript libraries. Package metadata has no way to declare them, so a scanner never reports them — even though their licenses and vulnerabilities are as real as those of any declared dependency.
Developer dependencies. Libraries we use to build our products never reach users, so we mark them with scope: "excluded". We list these libraries regardless, because all vulnerabilities should be documented.

We released a preview version of DevExpress-authored SBOMs in May 2026 (for our .NET NuGet packages). SBOMs for CRA Compliance in DevExpress-powered Apps describes what the files contain and how to feed them into tools such as Dependency-Track, Trivy, and Grype. With v26.2, we expect to extend coverage to NPM packages and DevExpress VCL libraries, take our SBOMs out of preview and make them available to every customer.

Middle-Tier Security — Stricter Application Model Permissions

XAF applications that store Application Model differences in a database must currently grant pre-login read/write access to ModelDifferenceXXX types for the Middle-Tier application server. We plan to narrow these pre-login permissions in v26.2. This will help customers with strict security requirements or when XAFML exposes sensitive Application Model settings before a user authenticates.

WCF Dependency Will Be Removed from XPO Core and Printing Libraries

These core libraries currently include references to WCF (Windows Communication Foundation), a standard library with a well-documented history of vulnerability disclosures in its dependencies ("thanks" to System.Security.Cryptography.Xml). We will remove these WCF references from DevExpress.Xpo core and DevExpress.Printing.Core libraries in v26.2. .NET Framework users will use the new DevExpress.Xpo.Services and DevExpress.Printing.Remote libraries instead (if you need this advanced and rarely used WCF functionality). The Project Converter will update project references automatically, so you should not encounter upgrade-related issues.

XPO ORM - Connection Provider Updates

We plan to support the most recent versions of the following database engines (for both .NET and .NET Framework) in XPO v26.2.

PostgreSQL
Microsoft SQL Server
SAP HANA 8
Oracle 26ai
etc.

Documentation

XAF Blazor

Scalability & Performance Optimizations

As you know, XAF Blazor scalability remains a top priority at DevExpress (number of concurrent web users). For information on our initial implementation (load test conditions, hardware, latency comparisons between versions, etc.), please follow our Technical FAQ updates.

By the end of 2026, we expect to publish the first production-ready version (Beta or RC) of our scalability-related enhancements:

"Crowd/Peak Load” (ALL users execute commands simultaneously), “Activity" (average user work day), and “Requests Per Second" (RPS) tests.
Additional enhancements based on ALL tests (XAF Core speed/memory usage and Blazor component rendering optimizations).
Published test results, load tests, configs, important considerations, and limitations for public review.

List Editor Context Menu Enhancements

We will switch to the native Blazor context menu within the XAF Grid, TreeList, and Pivot Grid list editors. The default menu will include standard grid commands: Column Chooser, Filter Editor, sorting and grouping controls, Find Panel, Best Fit, and others. A concise API for customizing the default menu items will also be available (for example, previously missing DxTreeListModel.CustomizeContextMenu and DxTreeListModel.ContextMenus APIs).

We will also ship basic runtime total/group summary customization in v26.2 (including the DXGridModelBase.TotalSummary and DevExpress.ExpressApp.Blazor.Editors.DxGridSummary APIs).

Blazor Pivot Grid Module — Official Release

The XAF Blazor Pivot Grid module will officially ship in our v26.2 release cycle. The official release will include updated demos, documentation, and full test coverage.

DevExpress Icon Library Integration

XAF WinForms and XAF Blazor will leverage the new DevExpress Icon Library as the default icon source for v26.2 -- giving both platforms access to the entire DevExpress Fluent icon set. A global toggle between classic and Fluent icon styles will be available at the application level. XAF's built-in Image Picker (in the Model Editor) will also be updated to present and save icons from the new library. Existing image and icon references in your applications will continue to work without modification.

Template Kit Enhancements and New GitHub Examples

XAF Template Kit: We will migrate to the ASP.NET Core Minimal API and simplify Blazor project files (for example, no Startup.cs file, less code, etc.).
Electron.NET example: We expect to introduce an example for cross-platform desktop applications built atop XAF Blazor with Middle-Tier Security, and Electron.NET, supporting Windows and macOS deployment from a single codebase. We previously delayed this task and dropped Template Kit integration due to the new ElectronNET.Core.API library.
.NET Aspire example: We will update our existing Aspire-based example with Microsoft Aspire 13.5. Aspire support simplifies database configuration and cloud deployment setup for XAF Blazor and Web API Service apps.

Artificial Intelligence (AI)

AI Integration Module — Official Release

Our AI Integration Module should be ready for production use in v26.2. The biggest new feature is certainly native AI Chat integration for both XAF Blazor/WinForms. Although it is already possible today with custom code, built-in form templates and other harnesses will save time for those using XAF.

Related community examples (with our AI Chat integration):

XafRag — RAG Sample for DevExpress XAF (GitHub.com)
AI Chat Integration between XAF and n8n (GitHub.com)
AI-powered SQL Chat for DevExpress XAF Blazor (GitHub.com)
GitHub Copilot SDK in a DevExpress XAF app (GitHub.com)
More on GitHub.com

Accurate XAFML Generation with AI Assistants

AI coding assistants currently struggle to generate correct XAF Application Model (XAFML) code. That is because XAF documentation includes very few XAFML code samples for individual model options. We plan to add XAFML snippets alongside online documentation and to publish a machine-readable XML schema for the Application Model. This will make contextual info available to the DevExpress MCP Documentation server and make AI-generated XAFML more accurate when using AI coding assistants.

Product-Tailored AI Skill Updates

We expect to extend and update the DevExpress AI Agent Skills repository based on user feedback (for multiple implementation tasks and AI coding assistants, such as GitHub Copilot, Claude Code, Cursor, and JetBrains AI Assistant).

The repository includes folders for different DevExpress products. Navigate to the dx-xaf directory to locate XAF-specific AI Agent Skills - coding assistants with built-in knowledge of XAF, its capabilities, related APIs, best practices, and code examples.

General MCP Server-related Updates

Our installer will now register the DevExpress MCP Documentation Server automatically (you can opt out via a checkbox), because it is a must-have feature when using AI coding assistants. NOTE: Our AI Skills already register the MCP Server by default (without conflicts).

Our MCP server will also support additional AI tools: to search Breaking Change listings (to improve your project upgrade experience).

If you have not yet evaluated our AI Agent Skills or MCP Server, please take a moment to review this community post for additional motivation.

Localization / Globalization

Blazor UI — Right to Left (RTL) Support (CTP)

DevExpress Blazor components and XAF Blazor will better support Right-to-Left (RTL) layouts in v26.2. Teams building applications for Arabic, Hebrew, and other RTL languages will be able to activate RTL across XAF Blazor UI elements, including our grids, editors, navigation, and form layouts (using a project-level option, without CSS or other workarounds).

New Localization Tool Integration

In our last release cycle (v26.1), the new DevExpress Localization Tool was updated to load strings from standard XAF modules (learn more). This change notwithstanding, XAF-specific strings customized in the Model Editor could not be transferred. We plan to close this gap in v26.2. XAF developers will be able to export Application Model strings and import them into the Localization Tool for translation, without manual file editing.

The deprecated Localization command in the Model Editor toolbar will also be removed in v26.2.

Improved Localization Support with AI-powered Translations

We expect to ship complete built-in localizations for a selected set of languages. Professional translators have already translated and reviewed approximately 80% of our German localization. To broaden language coverage while maintaining translation quality, we plan to leverage AI-powered translation workflows. The workflow will not rely on direct translation alone - it will also consider additional context:

Usage context - how each string is used, collected from our source code.
Established Microsoft terminology (obtained from the Microsoft Terminology Collection).

Web Localization Service — Supported Versions Limited to v23.2+

User translations for v23.1 and earlier releases will no longer be available through the Localization Service UI (view, edit, download, create). These translations will be retained by DevExpress should you require them. You can request your old translation archives via the DevExpress Support Center.

Postponed to 2027: While we confirmed that it is technically feasible to create a Blazor Model Editor (see our January prototype), we dropped its further development from our plans - we will have to re-think this completely after v26.2. AI chats greatly changed how users now manage even advanced application settings/tasks (like generate/modify complex reports or criteria expressions from natural language prompts) - our 15-year old and developer-centric Model Editor GUI (a tree list + property grid) may be simplified or replaced. We also postponed Fluent UI form template fine-tuning (app bar, side navigation bar, Tabbed MDI layout changes, etc.) as well as DateTimeOffset support (in data model properties) for key XAF List and Property Editors until the DevExpress WinForms and Blazor Component teams finalize this in v26.2. and our main strategic focus (web scalability).

Your Feedback Counts

If you have questions or suggestions about XAF v26.2, please share your thoughts in the survey below or submit a ticket via the DevExpress Support Center.

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

XAF Blazor/WinForms UI — Case Study by DataWerkes: Field Services Management Platform (TimeWerkes)

Dennis Garavsky (DevExpress) — Mon, 01 Jun 2026 12:49:00 Z

Meet DataWerkes (an independent software vendor in Alberta, Canada) and Keith Courneyea (a founder), who has been using our Cross-Platform .NET App UI (XAF) since 2019.

We recently published a case study about their flagship commercial product (TimeWerkes) powered by XAF WinForms/Blazor UI as well as DevExpress Blazor / WinForms (Grid & Data Editors, Charts, Pivot Grid, TreeList, Scheduler, Rich Text Editor), Reporting and BI Dashboard components.

Here is how Keith Courneyea described their product TimeWerkes (has been in active client use since late 2024):

TimeWerkes is a commercial, end-to-end field services management platform for industrial contractors. It manages the full business lifecycle of a contracting operation — from initial quoting through job execution, field ticketing (aka time reporting), inspection reporting, and final invoicing — within a single integrated application available as both a Windows desktop client and a Blazor Server web application. Currently the Blazor app in the primary client.

The platform is architected as a core business foundation with industry-specific modules that can be added as client requirements evolve. The core handles workflows common to all contractors: quotes, jobs, field tickets (aka timesheets) with labour and billable items, rate sheets, approval workflows, staff and certification management, equipment tracking, document management, and full invoicing. Specialized modules adapt this base for specific industries.

TimeWerkes is offered commercially. It is built on Microsoft SQL Server with Azure SQL in production and uses Azure Blob Storage for all document/image attachments, Azure Functions for background workflow processing, and Azure Communication Services for automated email notifications.

DataWerkes has been in operation for seven years. Keith's decision to build on DevExpress in 2019 was not the result of a product evaluation or a recommendation — it was a return. He had worked with DevExpress components in the early 2000s and had a positive experience that stayed with him. When he decided to pursue serious application development, DevExpress was the first place he went back to.

The specific choice of XAF as the framework was driven by what Keith needed as a first-time C# developer with a clear vision of what he wanted to build. XAF's model-driven approach — where defining a domain class in XPO produces a working UI, security system, and data layer without writing boilerplate infrastructure code — meant that Keith could focus on the business logic he understood deeply and let the framework handle the rest.

And here’s what Keith Courneyea said about XAF's primary benefits:

TimeWerkes uses the full breadth of the XAF module ecosystem. The Security System provides role-based access control across the entire application without custom authentication code. The Audit Trail module — extended through Llamachant's enhanced implementation — tracks every change across all 120 domain entities. The Validation module enforces business rules declaratively. Conditional Appearance drives dynamic UI behaviour. The Scheduler handles staff and job scheduling. Reports Module V2 powers 34 reports covering every business document in the system, from client-facing inspection reports to internal job cost summaries and invoices.

Critically, XAF's cross-platform architecture meant that the same core module and XPO domain model powers three deployment targets simultaneously: a WinForms desktop client, a Blazor Server web application, and an Azure Functions background processing host. A team of any size would find that a significant time saving. For a product owned by one person and built in partnership with a small development firm, it is what made the product possible at all.

Dave Hesketh of Llamachant Technology Ltd., whose team serves as the primary development partner on TimeWerkes, describes the XAF ecosystem as central to how Llamachant approaches every engagement. Llamachant's own framework extensions — including the workflow engine, Azure Blob file attachment integration, AutoIncrementingID, and LlamaLogger — are themselves built on top of XAF, which is a measure of how extensible and production-ready the platform is.

Read the full article to learn why DataWerkes chose XAF for cross-platform RAD project development and what they liked about our tools.

Get Started with XAF today if you want to build Office-like line-of-business (LOB) apps powered by Blazor and WinForms 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.

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 (Cross-Platform .NET App UI & Web API Service) — June 2026 Roadmap (v26.1)

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

EDIT: XAF v26.2 Roadmap | What's New in XAF v26.1

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.

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

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.

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