eXpressApp Framework Roadmap 2020 - Your Vote Counts

XAF Team Blog
10 December 2019
EDIT: Here is our final roadmap: eXpressApp Framework – 2020 Roadmap.

It's All 'Bout the Blazor, Blazor, Blazor

XAF v20.1 will include a CTP version of Blazor UI with XPO ORM for data access. XAFers will be able to create Blazor Server apps using the Solution Wizard (Blazor WebAssembly support is postponed until officially released by Microsoft). We expect to ship the following functionality for desktop and mobile apps:
  • Navigation control with group and item hierarchy.
  • Main menu with all standard XAF command types (buttons, popups, input/search boxes, drop-down menus).
  • Grid List Editor with sorting & grouping.
  • Detail form layout with group and tab controls.
  • Property Editors for all data types (no advanced editors for criteria, RTF, etc.).
  • Simple forms authentication with a login and password, role-based authorization and basic user/role management with access rights created in code (no specialized permission editors in the UI).
  • Data input validation with RuleRequiredField, RuleCriteria, RuleRange and other popular rules.
  • Multiple UI themes and a runtime theme chooser (similar to the 'gear' in the top-right corner of https://demos.devexpress.com/blazor/).
By our second release of 2020 (v20.2), XAF’s Blazor UI should be ready for production use. We hope to include additional XAF modules (please cast your vote below), online documentation, support for UI customization and advanced CRUD usage scenarios (as well as custom control integration). We also hope to support more end-user customization capabilities once they are included within individual DevExpress Blazor controls (for instance, grid column filters, add/remove columns, data export, inline edit).
We will continue to update XAF’s online Blazor demo with new features as they become available. Our next update (in 1-2 weeks) should include support for collection, reference, enumeration, Boolean, image and other data editors.

Housekeeping

  • We want to remove Visual Studio dependencies from the design-time Model Editor to increase stability and performance. We like the WPF designer that runs as a separate process and draws itself inside the Visual Studio frame. This will also help us support the Model Editor in .NET Core 3+ and .NET Standard 2+ projects (v20.1).
  • We will also incorporate a number of usability enhancements to the Model Editor based on user feedback - please let us know if you have any issues with this editor (v20.1).
  • We will monitor Microsoft updates with regard to the component designer in .NET Core 3+ and see if we can support our Application, Module, Controller and Action Designers. We will also support the SDK-style project format for all XAF design-time tools (v20.1, v20.2).
  • We will add support for Visual Studio vNext, .NET 5 and C# 8.0 features like Nullable Reference Types (v20.2).

Security System

We hope to publish Blazor, Xamarin and WPF examples for XAF's User Authentication and Group Authorization API powered by the XPO ORM (see our GitHub repository for more information). To make these examples more elegant and modern, we've thought about the following enhancements: 
  • Introduce asynchronous versions of popular security APIs (IsGranted, CanRead, CanWrite, CanDelete, etc.). 
  • Support token-based authentication.
  • Simplify XAF's security system integration with the help of utility libraries (they will encapsulate boilerplate code). 

We hope to support Entity Framework Core to help more DevExpress and non-DevExpress customers benefit from XAF's Security System. In v20.1, we will introduce a secured Object Space for EF Core 3.1+ and examples for corresponding platforms. Later in v20.2, we will support EF Core in our Blazor UI. We will decide on the EF Core support for WinForms UI based on user demand. Please share your thoughts on this subject in the survey below.

WinForms UI & Core

  • We hope support the following asynchronous operations out-of-the-box in the WinForms UI based on IObjectSpaceAsync introduced in v19.2: open List or Detail View, save View changes, save audit data (v20.1). If you are missing important use-case scenarios, please specify them in comments below.
  • We will support basic Entity Framework Core usage scenarios (v20.1) – those needed for XAF's Security System in non-XAF apps and Blazor UI (see above).
  • We want to rewrite our Tree List Editors module and support inplace data editing (v20.1), better filtering options and more features (S30514S30735 S38121) based on user feedback (v20.2).
  • We want to enable enhanced WinForms Filter and Expression editors in the Model Editor and within built-in List and Property Editors (v20.2).
  • We will make a number of Non-Persistent/proxy object enhancements (v20.2): support for filtering; propagate FindObject, CommitChanges, Refresh and other methods from NonPersistentObjectSpace to AdditionalObjectSpaces (T509228); support CRUD operations with non-persistent objects in a nested ListView of a persistent object DetailView (T486427T510338T695631).

ASP.NET WebForms 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 ASP.NET WebForms UI users.

Your Feedback Counts

Though we want to deliver everything (and deliver it yesterday), we can’t make any guarantees. As always we welcome your comments and specific usage-scenarios. The more you share, the better we can understand your business needs now and into the future.

Before we proceed to the 2020 Roadmap voting, please share your experience with the features we released in 2019.

What’s New in v20.1

To explore the scope, breadth and capabilities of our new products/features, please visit: https://www.devexpress.com/Subscriptions/New-2020-1.xml.
27 comment(s)
Bert Stomphorst
Bert Stomphorst
Sounds amazing, we're really looking forward to this!
10 December 2019
Chris Royle (LOB)
Chris Royle (LOBS)
An exciting list of goals.
10 December 2019
he dandan
he dandan
Most of the core of the enterprise is embodied in Grid.
I think it would be better to implement the function of Grid as soon as possible.
10 December 2019
Yahya
Yahya
Can the icons be changed to something more bright? Black icons look too conservative and bit ugly. May be use both Orange and Black?
10 December 2019
harvinder singh 4
harvinder singh 4
XAF v20.1 release date?
11 December 2019
Customer56436436
Customer56436436
I will partly agree with Yahya. it also seems that the titles and many graphic elements look bold-a little thicker than I would like. And of course I would like to hear some news(even negative) about the model editor in Rider. Is there any work in this direction? The external model editor does not provide that convenience.
11 December 2019
Mario Blatarić
Mario Blatarić

I am very excited about XAF and Blazor and future NET Core (and NET 5) support. 

Reports integration and good lookup editors (with filtering) are a priority for me. I have seen a blog about integrating asp.net reporting to Blazor and is fine for start, but I would really love to see "native" Blazor (and WebAssembly) in the future. 

I know it is far future, but OOB (out-of-browser) WASM has been proposed - and that would be ideal runtime environment for me. 

You know what would be amazing? Having multi-platform Model and Module editors, because with NET Core support I could maybe move entire XAF development to VS Code and macOS (which is my primary OS)? 

Now, how amazing would that be?! :-)

12 December 2019
Bassam Abdelaal
Bassam Abdelaal

the DV shown wastes a lot of space, was hoping Blazor will preserve space better then current xaf web new interface so users can see more controls in the screen at same time benefiting from big monitors now the common like 27" size, hope space between controls is an adjustable setting so we can squeeze them better for professional look and more useful usage

Thanks

12 December 2019
Mario Blatarić
Mario Blatarić

@Bassam - although current layout looks really nice - I agree that customers will ALWAYS want more data on the screen in certain type of apps (financial for example). 

Perhaps a "compact" version of UI which would have both smaller editors and spaces? Configurable - even better.

12 December 2019
Isa_Tahiri
Isa_Tahiri

I just went to the demo and it is very reactive ! Great job ! Can wait to see the CTP version :-)


BR

ISA

12 December 2019
Dennis (DevExpress)
Dennis (DevExpress)

@All: Thank you for your comments and voting in our roadmap survey.

>>XAF v20.1 release date?

Harvinder - around May time frame, as always.


>>Having multi-platform Model and Module editors 
Mario, how much do you use the Module and Application Designers? According to our stats, these design-time tools are rarely used. The Solution Wizard + minimal code changes to its output are sufficient for many users (we even thought about removing these designers in the future).

As for the Model Editor, we keep tracking user interest to Rider, VS Code and other IDEs. For now, the interest is very low to justify complex R&D in this regard. Anyway, .NET Standard 2 and .NET Core 3 support with the focus on the external Model Editor can open new possibilities for us or community plugins.

13 December 2019
harvinder singh 4
harvinder singh 4
Looking forward in Blazor Demo: Order/Invoice creation demo with inline editing with printing output
14 December 2019
Sergey Zaitsev (Xafari Team)
Sergey Zaitsev (Xafari Team)

What strategy will be used for Blazor?

I guess serverside?

14 December 2019
Mario Blatarić
Mario Blatarić

@Dennis - Agreed, Module and App designers are very rarely used and it would be more than fine to make them as XML/JSON files. It would be cool if there would be intellisense help for them - something like VSCode Preferences (non-visual).


NetCore and VSCode/Rider are all about cross-platform, so being able to develop XAF in VSCode ... would be really attractive for me, especially since I moved to macOS due to Windows update craziness (and I am just not a linux guy). 

But, this would also allow each developer to choose its own preferred environment, which is not possible if tools are tied to Visual Studio and Windows. 

So, external cross-platform Model Editor would be amazing addition to netcore stack.  

16 December 2019
Gosha (DevExpress Support)
Gosha (DevExpress Support)
@Yahya
Our team will take your suggestion into account. You will also be able to specify custom icons in XAF's Blazor UI using standard XAF methods.

@Bassam and Mario
Thank you for describing your user environments - we will take them into account.

@Harvinder
The ASP.NET Blazor team expects to ship grid inline editing in v20.2 - we will discuss its XAF integration after that. I've also informed our Blazor team of your printing-related request. Would using the reports for this task be an alternative solution for you? Regardless, please vote for features you'd like to see first in the Blazor - Roadmap 2020 (Half-Year) - Your Vote Counts post.

@Sergey
Yes, we use Blazor Server. For more information on this choice, see our previous post.

@Mario
Thank you for describing your development environment and expectations in detail. This cross-platform Model Editor is nice, but very costly feature. Roughly, one should weigh it against a full year of team work for many average XAF features.
16 December 2019
Paul R. Elliott
Paul R. Elliott
can I easily theme XAF Blazor with bootstrap ?
19 December 2019
Alain Bismark
Alain Bismark

Hi 

As I said in a ticket, we need to evolve XAF to create Microservices based applications, CQRS, Events Sourcing, support for Hexagonal Architecture..., use NoSQL database..., support Domain Design Driven.

Other things look cosmetic and not deep features.

my five cents...

20 December 2019
Mario Blatarić
Mario Blatarić

@Gosha

Maybe some shortcuts would be possible, depending on how much Model Editor code can be ported to net core.

UI could be then handled with devextreme components and entire Model Editor could be Electron app or even VSCode plugin.

Or just go crazy and create Blazor Model Editor :-)

Anyway, being able to develop XAF in VSCode on any platform would be ... well, amazing. 

Consider it at least since it is the only blocker to that path. Reports can already be designed on web and if you ditch Module/App designers and Controllers are better of without designer files anyways - Model Editor is the only one left. 

And it doesn’t have to happen in any immediate future, surely not before WebAssembly matures and ASP.NET 5 becomes a norm. 

9 January 2020
Yahya
Yahya

Model Editor Suggestion:

If in a detailview, layout window and the view items properties can be shown side by side (like winform form editor) then we we can see live effects of properties modification and it can save lot of time jumping between the two. This is perhaps the most inefficient part of model editor.

14 January 2020
Dennis Mitchell 1
Dennis Mitchell 1

Suggestion: XAF-FEO: (Front End Only):

(Perhaps this already exists?)  What if the XAF scaffolding engine looked for the presence of certain data-layer or service-layer interfaces (that met a DevExpress spec), and when these interfaces were discovered, optionally, it would bypass scaffolding of data/service layers and only scaffold a front end that pointed to the developer-provided interfaces?  And what if XAF's dependency injection container allowed the developer to point those same interfaces to his/her own back-end implementations?  Would this allow XAF to generate a front-end-only solution (with DI container support) that could work with non-XAF back-end solutions?


Is this a feature of XAF already?  If not, is it a feasible/sensible enhancement?  This feature might make it easier for us to transition to XAF over time and to build new XAF applications that took advantage of a microservices architecture.

17 January 2020
Dennis Mitchell 1
Dennis Mitchell 1

As a follow up to the above, perhaps it would be easier for DevExpress to provide the XAF data- or service-layer interfaces, rather than having the developer provide them according to some spec.  Either way, is something like this possible? 

17 January 2020
Dennis (DevExpress)
Dennis (DevExpress)
@Dennis: Thank you for your interest. This is something we were discussing recently too, but it requires more validation and thought. The feature is also very costly, because XAF is tied to the ORM layer (EF or XPO) and requires real .NET types for business objects. Currently, it is possible to make such integrations with non-persistent proxy objects only.

Since you thought about this topic a lot, what would you prefer for service layer integration? Have you looked into Swagger/OpenAPI and similar tools? What technologies are you using now to organize your microservices and how do they perform for your scenarios? I believe it will be better to look into open protocols instead of developing proprietary standards here. Feel free to email me at dennis at devexpress dot com, if you prefer to discuss it privately.

17 January 2020
Dennis Mitchell 1
Dennis Mitchell 1

@Dennis: We use Swagger/OpenAPI for interactively testing our APIs (to supplement our automated integration testing).  We are using regular .NET Core Web APIs for our microservices.

This is very quick, incomplete, and naive with respect to XAF, but I was imaging something like this:

using DevExtreme.AspNet.Data.ResponseModel;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

/// <summary>
/// The scaffolder would reflect upon an assembly, identify all
/// classes that implement IEntityModel, and use reflection
/// to build the XAF application model.
/// 
/// The scaffolder would also create clients that can invoke
/// the interface delegate properties for getting, creating, 
/// updating, patching, deleting, loading, and otherwise
/// querying the data via the runtime engine.
/// </summary>
namespace XafFeo {

	/// <summary>
	/// Holds pointer to POCO model class, as well as
	/// relevant Func and Action delegates that perform
	/// basic operations on entities.  Because these
	/// are delegates, any implementation can be provided
	/// (including HttpClient calls to a service, direct
	/// use of a DbContext ... etc.)
	/// 
	/// TEntity is the POCO class, possibly defined with reflectable 
	/// attributes from System.ComponentModel.DataAnnotations.Schema 
	/// and/or System.ComponentModel.DataAnnotations and which
	/// implements IValidatableObject 
	/// </summary>
	public interface IEntityModel<TEntity>
		where TEntity : class, IValidatableObject, new() {

		/// <summary>
		/// The name of the entity
		/// </summary>
		string Name { get; set; }

		/// <summary>
		/// Possibly provide variable meta-data
		/// without breaking the interface.
		/// </summary>
		Dictionary<string,object> OtherProperties { get; set; }

		/// <summary>
		/// An action delegate that validates the model.
		/// This may not be necessary if TEntity implements IValidatableObject
		/// </summary>
		Action<bool> ValidateAction { get; set; }

		/// <summary>
		/// A func delegate that returns a single entity by primary key
		/// </summary>
		Func<object[], TEntity> GetFunc { get; set; }

		/// <summary>
		/// A func delegate that creates and returns an entity
		/// </summary>
		Func<TEntity, TEntity> CreateFunc { get; set; }

		/// <summary>
		/// A func delegate that replaces and returns an entity
		/// </summary>
		Func<TEntity, TEntity> UpdateFunc { get; set; }

		/// <summary>
		/// A func delegate that updates and returns an entity
		/// </summary>
		Func<dynamic, TEntity> PatchFunc { get; set; }

		/// <summary>
		/// A func delegate that deletes an entity by primary key
		/// </summary>
		Func<object[]> DeleteFunc { get; set; }

		/// <summary>
		/// A function delegate that returns a DevExtreme LoadResult from
		/// the provided DevExtreme DataSourceLoadOptions parameters:
		/// <list type="number">
		/// <item>select</item>
		/// <item>sort</item>
		/// <item>filter</item>
		/// <item>skip</item>
		/// <item>take</item>
		/// <item>totalSummary</item>
		/// <item>group</item>
		/// <item>groupSummary</item>
		/// </summary>
		Func<string, string, string, int, int, string, string, string, LoadResult> LoadFunc { get; set; }

		/// <summary>
		/// A function delegate that returns an IEnumerable from
		/// the provided OData parameters:
		/// <list type="number">
		/// <item>select</item>
		/// <item>orderBy</item>
		/// <item>filter</item>
		/// <item>expand</item>
		/// <item>skip</item>
		/// <item>top</item>
		/// </summary>
		Func<string, string, string, string, int, int, IEnumerable<TEntity>> ODataFunc { get; set; }


		/// <summary>
		/// A function delegate that returns an IEnumerable from
		/// the provided Dynamic Linq parameters:
		/// <list type="number">
		/// <item>where</item>
		/// <item>orderBy</item>
		/// <item>select</item>
		/// <item>skip</item>
		/// <item>take</item>
		/// </summary>
		Func<string, string, string, int?, int?, IEnumerable<TEntity>> DynamicLinqFunc { get; set; }
	}

}

  

17 January 2020
Dennis Mitchell 1
Dennis Mitchell 1

For a purely service layer integration, you could specify REST endpoints for each of the interface methods.  I have a base controller class that provides endpoints such as these.  I am not aware of a published CRUD endpoint spec that would be sufficient, but perhaps one exists.

While integration at the service layer could be nice, the method that I proposed would give the option to the developer to implement the interface methods however they like -- with HTTP clients (e.g., calling an existing web API service layer), with gRPC clients (calling gRPC services), with EF clients, with XPO clients,  ... etc.  -- and they could use whatever back-channel security framework they wanted to use (e.g., an OAuth provider).

I can appreciate how expensive it would be to provide a feature like this, but it could make XAF more flexible and allow for a gradual migration of existing apps to XAF.  Does this make sense?

17 January 2020
Mario Blatarić
Mario Blatarić

In one of my post I was rambling about XAF being able to use WebApi as data source - and Dennis's proposal is really close to my cloudy thoughts. 

It would be perfect companion to WebAssembly XAF one day because in WebAssembly we can't use direct connection to database, so UI will be disconnected from Business Objects - and it would be VERY nice if app generator could use interfaces like this to both generate UI and do CRUD operations. 

Also, having something like this would allow us to instantly switch between server-side and client-side Blazor inside same app. 

We actually have need for both because we still have quite a few clients with slow computers which might benefit from server-side Blazor and we also have clients with bad networks (using 2.4Ghz wireless for main networking, for instance) which could benefit from client-side Blazor. 

However, this is a minor point compared to client-side Blazor XAF which could both generate UI and manage data through such interface. 

Maybe we could open a ticket for this? I forget to check this blog comments and miss new posts.

20 January 2020
Dennis Mitchell 1
Dennis Mitchell 1

@Mario, thanks for the input. 

@Dennis, should I open a ticket?  I know that it is a heavy lift for DevExpress, but I do think that XAF (and potential users of XAF) would benefit considerably.

With the increasing popularity of Salesforce (and its competitors), there is pressure to build apps faster and faster, and it is getting harder and harder to argue for traditional custom development.  With the proposed enhancements to XAF, XAF could become a viable custom-development tool for us -- allowing us to develop at near-Salesforce speed but still giving us the flexibility to maintain and evolve our service layer and data layer as we would like it.


20 January 2020
Dennis (DevExpress)
Dennis (DevExpress)
@Dennis and Mario: Thank you for your comments. IEntityModel and other ideas make sense - our team will take them into account.

If you or other interested users want to elaborate on custom CRUD service requirements, I suggest you use the following ticket: https://supportcenter.devexpress.com/Ticket/Details/T400009/can-i-connect-an-xaf-application-to-a-custom-data-source-web-service-odata-service-nosql.
20 January 2020

Please login or register to post comments.