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

UPDATE: What's New in XAF v23.2 and XAF v24.1 Roadmap 

---------------------------

This blog post outlines some of our XAF-related development plans for the second half of 2023 (v23.2). As you will see below, key focus areas will continue to remain Blazor, EF Core and .NET 8.

Common / Cross-Platform / Core Enhancements

.NET 8 Support

Simple and straight to the point: We will support .NET 8 across our XAF Blazor/WinForms UI and Web API Service.

End of .NET Standard 2 Support

With our next major update (v23.2, set for release in December 2023), our assemblies will not be built against this target. Learn more about this change in the following blog post: .NET — .NET Standard 2.0 Deprecation, Support for .NET 6 or .NET 8 (LTS) in DevExpress Libraries (v23.2).

DevExpress Drawing Library Support for Straightforward non-Windows Development

We will eliminate use of System.Drawing.Common references across XAF Blazor/WinForms UI and Web API Service. This will allow our cross-platform libraries to work as expected across Linux, Mac, Windows, Android, iOS for .NET 7, .NET 8 and future target frameworks. This change will also simplify future development and deployment for new UI platforms, such as .NET MAUI and Blazor WebAssembly with .NET 8+.

All these benefits come at a cost of breaking changes such as removal of APIs from the System.Drawing namespace (Image, Bitmap, Color, Font, FontStyle, etc.). Affected XAF modules include Conditional Appearance, Security, ImageLoader, etc. (they will now use replacements from DevExpress.Drawing like DXImage, DXFont, etc.). However, we believe our modernization strategy is certainly worth the effort.

For more information on this and existing solutions today, please review related articles:

• DevExpress Drawing Library Goes RTM (v23.1)
• Develop a DevExpress XAF and Web API Solution in Docker
• Deploy and scale an XAF Blazor Server app: use Azure Kubernetes Service to serve hundreds of users
• PlatformNotSupportedException occurs when an XAF Blazor or Web API app explicitly adds the System.Drawing.Common 7.0 package...

Web API Services Powered by EF Core & XPO ORM

As you may already know, our FREE Web API Service supports basic CRUD, authentication/authorization for EF Core/XPO. The DevExpress Web API Service is available free-of-charge (register your free copy today). Active DevExpress Universal Subscribers can also access many advanced paid features included in our Web API Service (such as audit trail, validation, reporting, file attachments, localization, and non-persistent object support). To learn more about our Web API Service and determine whether it can be of value within your organization, please review the following blog post: Common Questions about the New DevExpress Web API Service (powered by Entity Framework and XPO ORM).

In v23.2, our Web API Service will automatically generate endpoints for business object methods (decorated with the ActionAttribute). These endpoints can accept a number of parameters and are automatically displayed in the Swagger UI. This is a highly-request feature by both XAF and non-XAF customers as it improves code sharing and saves time/code lines (since you do not need to create custom Web API controllers manually). Of course, you can hide or customize these endpoints in code. Available in v23.1.5 as a preview (for early testing), official release in v23.2.

public class Task : BaseObject {
    public virtual DateTime DueDate { get; set; }
    [Action(Caption = "Postpone a task for N days",  
        ToolTip = "Postpone a task. The \"Days\" parameter specifies the number of days the task should be postponed.", 
        TargetObjectsCriteria = "Not [IsComplete]")]
    public void Postpone(PostponeParameters parameters) {
        DueDate += TimeSpan.FromDays(parameters.Days);
    }
}

Multi-Tenancy Module for Blazor and WinForms - Official Release

The Multi-Tenancy Module was first introduced in June 2023 as a Community Technology Preview (CTP). As you may recall, this module helps developers create multi-tenant or SaaS-ready XAF Blazor and WinForms applications (.NET 6+) that target a single database or one database per tenant. To incorporate this capability, you simply need to write a few declarative lines of code instead of writing hundreds of lines of code.

Our v23.2 update will mark the first official release of the DevExpress Multi-Tenancy Module and will include the following:

• XPO ORM support (v23.1 supported only EF Core)
• Authentication: Log in with an email/URI/token and a password (the domain automatically resolves the tenant and its storage)
• Tenant Isolation: Multi-tenant app with multiple databases (a database per tenant)
• Database Creation: Application automatically creates a tenant database and schema at runtime (if the database does not exist)

Error/Best Practice Code Diagnostics

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

Sensitive Data Is Removed from XAF Log Files by Default

We modified the structure of records that we output to the audit log so that these records do not contain data that may be sensitive. For more information, please review this Breaking Change notice.

XAF ASP.NET Core Blazor UI

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

Grid List Editor Enhancements

We will support the following features in our DxGridListEditor in v23.2:

• Context menu for grid headers (just like WinForms/WebForms counterparts). For instance, Column Chooser, Hide Column, Group by Column, Show Auto Filter Row, Filter Editor, or Reset View Settings commands should be available in this context menu.
• Images for enumerations in column header filters
• Best Fit for grid columns and 100% height for the grid container
• Add hyperlinks for reference/lookup properties in ListView (to open a detail form for a related record faster).
• Tooltips for grid columns
• Inplace / Grid Row-based Actions

Find Window in Lookup Property Editor

We hope that our enhanced Lookup Property Editor will better address the following common tasks:

• Search data against a single/multiple fields fast (even for large datasets - just like XAF WebForms...see the screenshot below. To deliver this functionality, our lookup editor will include a Search button and this button will display a separate Find window with a standard data grid and search controls. This Find window will also allow you to create new records using the standard New Action.
• Use all criteria language features for EF Core and XPO ORM without limitations. Unlike a simple combo box, the Find window will host the standard data grid with all its powerful features, including server mode.
• Open a complete detail form for the related record (currently selected lookup value) using a hyperlink. This feature will be helpful for those who do not want to view and edit related details in a separate window (currently provided by the Edit button).

Miscellaneous Usability Enhancements

• Modified ImmediatePostData attribute behavior so that XAF Blazor replicates XAF's WinForms UI.
• Add Save & New Action to popup windows.
• Allow end-users to resize List and Detail Views via a splitter when IModelListView.MasterDetailMode is ListViewAndDetailView. The view's new splitter position is saved in the Application Model in the IModelListViewSplitLayout.ViewsOrder property (end-user settings are stored in the database by default when the Security System is enabled).
• Open multiple popup windows, with drag and resize capabilities.
• Support updates and filtering of dependent/cascade lookup editors using the UsedProperties parameter of the DataSourceProperty attribute (at present, you need to refresh these editors in code using a Controller) 
• Bypass adapters and access control options in code for List and Property Editors (example: DxGridListEditor.GridModel vs DxGridListEditor.GetGridAdapter().GridModel - learn more).

Scheduler Module - Official Release

The Blazor Scheduler Module was first introduced in June 2023 as a Community Technology Preview (CTP). Our v23.2 update will mark its official release and include the following:

• Performance boost for large datasets (we are already testing some of these enhancements in v23.1).
• Simplified Status and Label editor customization (current solutions).
• Enhanced recurrence editor and new documentation for most popular tasks (how to customize scheduler appointments, appointment mappings, access underlying business objects for appointments, filter resources, etc.).

New Blazor Hosting Modes in .NET 8 and XAF Blazor Compatibility

As you may already know, Blazor in .NET 8 unifies Blazor Server and Blazor WebAssembly hosting modes (learn more from Carl Franklin's video). XAF Blazor is solely powered by Blazor Server (from day one). In v23.2, we will ensure that XAF Blazor Server will work properly with .NET 8 and the latest ASP.NET Core enhancements.

We are not planning to support Blazor WebAssembly/WASM in XAF Blazor v23.2 (it makes little sense for the majority of XAF users based on user feedback so far). As you may recall, we intentionally chose Blazor Server due to key limitations in Blazor WebAssembly itself (for complex line-of-business apps).

In late 2023/early 2024, we will explore multi-threading issues and benchmark Blazor WebAssembly performance once again (to help determine future development strategies). 

XAF WinForms UI

Enhancements to Middle Tier Security for EF Core

As you may know, XAF UI v23.1 for Windows desktop can better meet enterprise security standards with its Middle Tier application server (powered by EF Core 7 ORM). With our solution, EF Core developers can retain their standard DbContext and initiate remote connections to a data store from any .NET client (like XAF WinForms or non-XAF apps). This capability is critical within certain environments/business apps (those that cannot maintain direct database connections because of security considerations).

Thanks to customer feedback and in-house "dog-fooding" efforts, v23.2 will include a number of Middle Tier-related enhancements (such as refresh tokens with JWT authentication and fixes based on additional real-world scenarios).

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

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

XAF WebForms UI

Content Security Policy (CSP) Support

XAF's ASP.NET WebForms UI will support Content Security Policy (CSP). CSP helps developers automatically detect and mitigate specific security risks, including Cross-Site Scripting (XSS) and data injection attacks.

Your Feedback Matters

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

Free DevExpress Products - Get Your Copy Today