XAF - 2021 Roadmap (Cross-Platform .NET App UI and Security API)

XAF Team Blog
11 February 2021
UPDATE: Here is our 2022 Roadmap

Before we detail XAF’s 2021 Roadmap, our thanks to everyone who shared feedback/thoughts over the last few months. Your contribution is both important and greatly appreciated.

The following list outlines the features/capabilities we expect to introduce in the eXpressApp Framework (XAF) this year. As with our 2020 roadmap, we will keep this 2021 roadmap post up-to-date as we release new functionality or clarify our future plans throughout this year. As such, please do bookmark this page so you can return to it and track our progress. 

ASP.NET Core Blazor UI

XAF's Blazor UI was officially released in v20.2 (October 2020) - it is ready for production use in simple CRUD scenarios (documentation).

First, some good news: XAF's Blazor and WinForms UI v21.1 assemblies, demos and project templates will target .NET 5 instead of .NET Standard 2.1 and .NET Core 3.0 respectively. This will bring with it new capabilities, both for us and also for XAF users: CSS and JavaScript Isolation, new Microsoft Identity Web packages for the latest Azure Active Directory SDK, performance and debugging enhancements, etc. For more information on this topic, please review these Microsoft articles: The future of .NET Standard | What's new in ASP.NET Core 5.0 | Migrate from ASP.NET Core 3.1 to 5.0.

In 2021, we also expect to offer feature parity between Blazor and our WinForms/WebForms UI for the most popular usage scenarios:

  • Localization. We will introduce easier multi-language localization (like in WinForms/WebForms) support with predefined resources or via the Model Editor (example). Available in v20.2.6.
    In addition, XAF's Blazor UI developers will be able to switch languages at runtime. Available in v21.1.

  • Clone Object Module for XPO - Available in v20.2.6.

  • Audit Trail Module for EF Core. Audit Trail will support both XAF UI apps and non-XAF apps. Available in v21.1.
  • Office Module. A wrapped JavaScript Rich Text Editor will be used to edit rich text documents from within your XAF-powered Blazor UI apps (example for older versions). Available in v21.2.


  • Dashboards Module. A wrapped JavaScript Dashboard control will be used to design and preview dashboards. The majority of XAF developers said that they were happy with this module for most data analytics usage scenarios (example for older versions). Available in v21.2.

  • Scheduler/Calendar/Notifications Modules (!). As part of our support for this feature, our base DevExpress.ExpressApp.Scheduler assembly will be made cross-platform for advanced usage scenarios. In the meantime, you can implement a custom List Editor based on the DevExpress Blazor Scheduler control (example). Postponed to 2022.

  • Action Container View Item. This item will help you include Actions into your detail form layout instead of the main menu (example + see a screenshot below under State Machine). Available in v20.2.6.


  • User Profile Avatar. The Security System allows you to specify a user image/avatar and display it in the top right corner of your application page. Available in v21.2.
  • New Property Editors (!). We will support Nullable, TimeSpan (Available in v21.1), Color, Tag Box, Hyper Link Property Editors and a faster Lookup Property Editor (with the New and Open buttons - Postponed to 2022out of the box.

  • Grid List Editor. We will support more options in our Grid List Editor such as runtime column chooser, footer summaries (example), find panel, column header filters, etc. This feature relies on the DevExpress Blazor Grid, so please follow our ASP.NET team blog for roadmap updates as well. Available in v21.2 (CTP).
  • Popup Window Customization. We will include more options to modify pop-up window size (example), position, style and other settings (similar to our WebForms implementation - example). Postponed to 2022
  • Chart and Pivot Grid List Editor Modules (!). Based on our roadmap survey, only 15.5% of XAF developers wanted these modules for data analytics scenarios in XAF's Blazor UI. We will decide on these modules at the end of 2021, once we ensure support for more popular modules first (for instance, the Dashboards Module that handles many data analytics scenarios). We received almost zero feedback on the old KPI, Pivot Chart (aka Analysis) and Maps modules and will not likely support them in 2021. In the meantime, customers, who wants these modules or other controls that are unavailable out of the box, can integrate standalone JavaScript and native Blazor charts, pivot grids, tree lists, diagrams, or maps in their Blazor apps using standard XAF extensibility techniques: custom View Items, custom Property Editors, custom non-XAF forms or even reports. For instance, review our custom Pivot Grid List Editor example for Blazor. Please contact our support team if you require assistance in this regard.
  • State Machine (Available in v21.1) and Workflow Modules (!). Though we confirmed that this is a low popularity module for our users, (only 7% wanted it for XAF's Blazor UI), we decided to support this module as it was easy for us to do so (all tests passed successfully). Based on the roadmap survey, most users either did not find workflow-related scenarios important or preferred the simplicity and flexibility of Controllers with Actions (example). As for former Workflow Module scenarios, we also recommend that users implement Controllers or custom solutions such as Hangfire, Quartz.NET, and others - WWF and WCF will not be ported  to .NET Core/.NET 5 by Microsoft. To save time with these advanced workflow scenarios, consider this free module within the eXpand Framework.
  • Tree List Editors Module (!). While we do not plan to support this out of the box in 2021, you can already implement a custom TreeList Editor for Blazor as per our example that is based on the DevExtreme/JavaScript component. We rely on the availability of DevExpress Blazor components here, so we may reconsider this in 2022.

Windows Forms and ASP.NET Web Forms UI

Our primary focus will be on XAF’s new Web & Mobile UI for Blazor. This notwithstanding, we will do our best to address the needs of existing WinForms and ASP.NET WebForms UI users. For instance, WinForms app users can expect the new View in Model Action, Enhanced Mask Settings and other usability enhancements in the Model Editor. 

We will also focus on making it easier to migrate existing .NET Framework apps to .NET 5 or use existing apps alongside new Blazor projects. We will also extend our .NET 5 migration-related documentation based on additional migration scenarios.

Cross-Platform Enhancements

Security System

We will support Middle Tier Security in our WinForms UI for .NET 5 at the end of 2021. In the meantime, it is possible to connect XAF's WinForms .NET 5 clients to an application server running on .NET Framework. Available in v21.2 (CTP).

We will also keep enhancing XAF's Core and Security System API for asynchronous data processing in 2021. This is important for both XAF's Blazor UI and non-XAF usage scenarios (like authorization in Blazor WebAssembly apps with XPO or EF Core). Postponed to 2022.

We've also got some good news for those considering our Security API for future use in non-XAF apps. As a registered DevExpress.com user, you are entitled to a free copy of .NET Role-based Access Control & User Authentication API powered by Entity Framework (EF Core) and DevExpress eXpress Persistent Objects ORM (XPO). 

Entity Framework Core for Data Access

v21.1 will also mark the official release of Entity Framework Core (EF Core) support in our Blazor UI (we included it as a CTP in v20.2). Available in v21.1.



Core and Performance

A new DataAccessMode = Queryable will be available for faster lookups in XAF's Blazor UI and also easier integration with external data sources beyond supported ORM (Available in v21.1). Other performance enhancements will affect the Audit Trail module and the Model Editor. If you want to improve performance today, profile your app and review our best practices. Experience suggests that most issues can be addressed at the custom code or on the database side.

Designers and Wizards

v21.1 should mark the official release of the Model Editor for .NET 5 apps. Available in v21.1.

We will NOT support Module and Application Designers in .NET 5 (.NET Framework apps will be unaffected), because they mostly duplicate Solution Wizard functionality and are rarely used (occasional configuration can be easily accomplished with a few lines of code, especially in Blazor apps: example). We may support Controller and Action Designers in 2021 should demand require it – as its implementation is very complex because of the changes made by Microsoft to Visual Studio’s architecture. Note that it is possible to create Actions with a few lines of code (example).

Our Enhanced Solution Wizard will will include one the following capabilities by the end of 2021:

  • create a combined WinForms + Blazor .NET 5 solution or add a new .NET 5 Module to an existing WinForms or Blazor solution. Available in v21.1.


  • create a solution with OAuth identity providers without writing any custom code. Available in v21.1.
  • extend a security user class with additional properties (the roadmap survey confirmed that most users create "public class MyUser: PermissionPolicyUser" - example). Available in v21.1.
  • create a solution that will target a single database or a database per tenant for SaaS scenarios (example). Postponed to 2022.
  • reuse XAF application data, logic and modules by Non-XAF apps using a separate Web API backend service project (or extended Blazor project) with Swagger (OpenAPI). This should help XAF users reuse application data, logic and modules in Non-XAF apps (examples) much more easily. Many XAF customers have already created such backend services for their XAF production systems, for instance, Martin Praxmarer of PraKom for his mobile Xamarin companion app or this gentlemen on YouTube  - we simply want a "1-Click" solution for everyone using XAF's Solution Wizard. Available in v21.2 (CTP).

    Image
  • A solution with pre-built error diagnostics using Roslyn Analyzers. XAF/XPO users will see a detailed error report locally or make this "best practice" analysis a part of their CI system. For this, I collected more than 35+ common errors made by XAF/XPO users in their projects (also thanks to Alex Miller for his contribution). Common errors include missing INotifyPropertyChanged, XPO attributes on non-persistent classes, or unhandled unusable nodes. Available in v21.2 (CTP).
    Image
  • create a Blazor solution with functional testing (Available in v21.2) and CI/CD infrastructure for Azure DevOps (example). Postponed to 2022.
  • Dependency Injection (DI) for security, modules and other WinForms .NET Core project configurations like in MAUI or XAF's ASP.NET Core Blazor Server. As you may recall, we want to move away from Application and Module Designers - most XAF users do not use them and favor the Solution Wizard and simple code changes (confirmed by our roadmap survey). Note: please do not confuse these designers with the Model Editor - - the main XAF visual designer that is well-supported for .NET Core/.NET 5.

The list of planned enhancements is significant, so we cannot promise that everything will be completed this year. We will regularly update this post to reflect our latest vision.

More LINQ-based Filtering (XAF, XPO and related products)

Inspired by XAF's lambda-based methods like IObjectSpace.FirstOrDefault, we will extend the CriteriaOperator class for all DevExpress customers to create type-safe criteria more easily in v21.1. The new CriteriaOpertor.FromLambda<TModel,TResult> method will support common LINQ expressions and methods, most used CriteriaOperator descendants and custom criteria functions or aggregates. Available in v21.1.


// FROM
CriteriaOperator.Parse("Name = ?", "Gera");
// TO
CriteriaOperator.FromLambda<Customer, bool>(cm => cm.Name == "Gera");
//-------------------------
//ConstantValue
CriteriaOperator.FromLambda<Customer, int>(cm => Discount * Price * 0.8 );
// OperandValue
CriteriaOperator.FromLambda<Customer, int>(cm => Value);
// OperandProperty
CriteriaOperator.FromLambda<Customer, string>(cm => cm.Name);
// BinaryOperator
CriteriaOperator.FromLambda<Customer, bool>(cm => cm.Age >27);
// UnaryOperator
CriteriaOperator.FromLambda<Customer, bool>(cm => !(cm.IsLongterm));
// FunctionOperator
CriteriaOperator.FromLambda<Customer, bool>(cm => cm.Name.Contains("Gera"));
// AggregateOperand
CriteriaOperator.FromLambda<Customer, int>(cm => cm.Orders.Count());
// JoinOperand
CriteriaOperator.FromLambda<Customer, int>(cm => JoinOperand.FromLambda<Order, 
int>(om => cm.Oid == om.CustomerOid && om.Price > 5, g => g.Count()));
// Group Expressions
CriteriaOperator.FromLambda<Customer, bool>(cm => cm.Orders.Count()>10 &&
 cm.Islongterm && cm.Orders.All(om => !(om.IsComplete)));

XAF customers will especially enjoy the new methods to create predefined object and member security permissions in the ModuleUpdater class. Of course, there are many other helpful use cases in Controllers and business classes for filtering. Available in v21.1. 

securityDemoRole.AddObjectPermissionFromLambda<PermissionPolicyUser>(SecurityOperations.ReadOnlyAccess, t => t.Oid == (Guid)CurrentUserIdOperator.CurrentUserId(), SecurityPermissionState.Allow);
securityDemoRole.AddMemberPermissionFromLambda<PermissionPolicyUser>(SecurityOperations.ReadWriteAccess, "ChangePasswordOnFirstLogon; StoredPassword", null, SecurityPermissionState.Allow);
securityDemoRole.AddObjectPermissionFromLambda<PermissionPolicyRole>(SecurityOperations.ReadOnlyAccess, t => t.Name == "Demo", SecurityPermissionState.Allow);

Note that CriteriaOperator.FromLambda does not support any possible LINQ expression, because our criteria language and LINQ are not 100% compatible. For instance, GroupBy, OrderBy and other LINQ methods used for filtering are not supported. 

We will also keep XPO connection providers up to date with the latest database engines and extend learning materials for the main platforms wherein XPO is used based on user feedback (for instance, Blazor WebAssembly, MAUI and WinUI).

We will also support System.Text.JSON serialization for XPO objects (our example will use PersistentBaseConverter and PersistentBaseConverterFactory). Available in v21.1.

Your Opinion Counts

As always, we look forward to your comments and questions via email: xafteam@devexpress.com. See also EAP announces and version history documents:

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.

Need Faster Support Replies?

Once you create a new XAF ticket in the DevExpress Support Center and select XAF under the Platform/Product field, please review the following help links displayed above the Submit button. These links describe how you can collect callstacks, logs and other important diagnostic information for any .NET error. Once you collect/compile this information, forward it to us along with your support ticket. This information will ensure faster and more accurate replies from support.