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

Masks for Date and Time properties

XAF Blazor Date and Time Property Editors support masked input. The `EditMask` property now restricts user input and you can specify it in the Application Model: BOModel > YourBusinessClass > Property > `EditMask`. Furthermore, you can 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 will 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 XAF team has spent some time considering the functionality of Aspire, attempting to find the best integration points which will allow XAF developers to take advantage of the orchestration features Aspire offers 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, which could achieve some of these goals:

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

The team hopes that we will be able to save a lot of time for our customers, whether they use XAF or not! Right now, much of this is a moving target, since Microsoft continues to develop Aspire rapidly. At the same time, some functionality is already commonly used and can be considered stable, so for now we decided to publish some details that will help you make use of the Aspire tools in your own XAF projects. Please refer to the following articles:

• .NET Aspire Support for an XAF Blazor Project- Introduction
• Custom Telemetry, Service Orchestration, Database Dependency
  

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). The functionality 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 the functionality 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 the 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;
           })

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

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

In v25.1, we implemented the MiddleTierClientBuilder that simplifies boilerplate code required to connect non XAF-powered WinForms/WPF apps to a Middle Tier Security Server (via XAF's Security System and EF Core). For more information, check out our WinForms non-XAF example. Our new Template Kit will also include the corresponding non-XAF project templates for WinForms/WPF in the final 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:

• DataSourceCriteriaAttribute
• DataSourceCriteriaPropertyAttribute
• DataSourcePropertyAttribute

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.

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 the 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 the Post, Patch and Put HTTP verbs).
• OData Batch Operations (aka Batch Update support). Now you can use the new Patch(DeltaSet<TEntity> deltaSet) method to create/update large amounts of objects.