Community News

1. Check out two new blog posts on unit testing from Manuel Grundner (DevExpress MVP): 
   T is for Testing: XAF & XPO - Builder Pattern 1 | T is for Testing: XAF & XPO - Test Data 2.
   These posts will be interesting for those creating complex apps with XAF.
2. The eXpand Framework, managed by Apostolis Bekiaris, continues to release new platform-agnostic packages for XAF: http://xaf.expandframework.com/. eXpand’s new ProgressBarViewItem and HideToolBar add to the dozen plus low-dependency modules managed by Apostolis. Note: If you have not reviewed eXpand recently, you should definitely take a look at its new modules…they are smaller, include documentation, and ship Azure unit tests (Apostolis has also added usage examples, videos and troubleshooting info). Give it a try and please share your thoughts with us.
   
   
3. A new version of XAFARI with full support for XAF v19.1.3 is available (DevExpress updates are slightly ahead of XAFARI versions). As you may know, Galaktika Soft has been providing paid reusable XAF modules with documentation and support services for more than 5 years.
4. A new case-study about a Human Relation Management solution using XAFARI and XAF is available here. We also published XAF case studies from two other loyal XAF users last month: Case Study 1 | Case Study 2.
5. We asked our customers about their thoughts on Blazor and received numerous comments. Since our ASP.NET team is fully committed to the Blazor platform, we are investing how Blazor can be used with XAF. We may modify our React-based SPA UI strategy and focus our efforts on Blazor going forward (our initial impression is that Blazor better fits the long term needs of our customers). We will publish additional info as it becomes available.

 Documentation Updates

• Our tech writers are working hard to make certain that each popular class and member help topic includes a helpful code snippet. Here are the XPO API updates - more than 20 examples with overloads: 
  Session.ExecuteNonQuery | Session.ExecuteNonQueryAsync | Session.ExecuteQuery | Session.ExecuteQueryAsync | Session.ExecuteScalar | Session.ExecuteScalarAsync
  Session.FindObject | Session.FindObjectAsync | Session.GetObjectByKey | Session.GetObjectByKeyAsync
• If you’ve never tried XAF, please be sure to review our introductory online tutorial – it should give you a solid understanding of what’s possible with XAF: Basic Tutorial.
• New Office module help topics:
  Office Module Overview | Use Spreadsheet Documents in Business Objects | Access the SpreadsheetControl | Access the RichEditControl
• Everything XAF developers should know about modern Splash Forms for their WinForms apps:
  Manage Splash Forms in an Application | Customize Built-In Splash Forms | Create and Show a Splash Form 
  Use a Custom Class to Show a Splash Form | Localize a Splash Form
• Learn how to configure custom XAF WinForms templates for the best possible performance via the WinApplication.RunSetupInNewThread option available in v19.1:
  How to: Create a Custom WinForms Ribbon Template | How to: Create a Custom WinForms Standard Template
  XafApplication.CreateCustomTemplate | CreateCustomTemplateEventArgs.UseDefaultTemplate
• Recommended ways in which to bind data grids and other data-aware controls to XPO data (for WinForms and WPF): XPBindingSource Class.
• As you may already know, the parameterless IObjectSpace.CreateObjectSpace() method was hidden from Intellisense. We have also updated many XAF GitHub code examples with the recommended CreateObjectSpace(Type) overload so you can derive best practices from them. 
• To avoid NullReferenceException in advanced multi-threading scenarios, check if your INotifyPropertyChanged implementation uses the null-conditional operator (?.) in C# 6. With We have updated our docs and Item Templates accordingly (XAF v19.1.4).

Usability & Performance Enhancements

• To save time with functional XAF testing, check our Notepad++ and Visual Studio Code extensions for EasyTest files (*.etc, *.inc): syntax highlighting, collapsible regions, code snippets and more. In our opinion, functional and unit tests are a must for teams creating complex apps. We would appreciate your feedback here or in comments to this KB article.
• With XAF v19.1.4, we no longer check the TargetObjectsCriteria value for disabled or inactive actions. An Action criterion is evaluated only when the Action is activated and becomes visible. For more information, please see this ticket. 
• Did you know that CodeRush's Code Cleanup feature can automatically replace hardcoded property names in XPO/XAF business objects with nameof? For more information, see this ticket.
• XAF v19.1.4 demos include fixes for high DPI displays: navigation panel and lookup/popup window widths are modified more effectively (they are no longer narrow and certain Web images are no longer blurred). For more information, see the following tickets: one, two. If you’ve experienced other 4K/SVG related issues, please submit your comment below.
• We moved deprecated Item Templates (XAF v19.1.5) into a section at the bottom - this will preclude them from accidental selection. Recommended templates are placed at the top and are sorted by popularity. For more information, see this ticket. 
• With XAF v19.2, we no longer display the save confirmation dialog when a user closes DetailView for a new unmodified object in a WinForms application. For more information, see this breaking change. 
• With XAF v19.2, the IObjectSpace.ObjectChanged event is no longer raised for control value changes (because of performance issues). For more information, see this breaking change.
• With XAF v19.1.5, we load all objects required by RecordsNavigationController (current, next and previous objects) in one query when DetailView is opened through ListViewProcessCurrentObjectController. Currently, ASPxGridListEditor, WinForms GridListEditor, SchedulerListEditor and TreeListEditor call this API when an object is double-clicked or ENTER is pressed. This should be a bit faster on slow connections. For more information on usage scenarios, feel free to review the following tickets: one, two, three. 
• Check my comment at the bottom of this ticket and help us decide on a feature we have planned for WinForms (v19.2) - collapsible layout groups.

Noteworthy Support Center Tickets

• T741546: Don’t miss the Visual Studio 2019 version 16.1 or newer update where DevExpress project templates are categorized as expected.
• A2670: We keep recommending that our users try Native Image Generator (NGEN) to dramatically cut app and form load times. 
• K18167: We described how to use STASafeDataStore in an XAF app to resolve the "Entering the 'GetObjectsNonReenterant' state..." error caused by a known .NET Framework specificity
• T741228: We clarified the assembly versions loaded in a complex XAF solution (with projects for both .NET Framework and .NET Standard).
• T742517; We demonstrated how to load multiple file attachments using a custom ViewItem based on the ASPxUploadControl (XAF Web app).
• KA18699: We updated a popular KB article regarding ways to define calculated properties.
• T741894: We demonstrated how to use the CustomizeTypesInfo method in a multi-threaded scenario (Web app).
• T749921 | T741871: We discussed usability, printing and performance of the new rich text editors in XAF WinForms and WebForms apps.
• E4908: We started a series of posts on how to use the XAF security system functions in non-XAF .NET apps using XPO for data access. This example contains a security system feature overview and the first Console demo.

We recently began a series of posts designed to explain XAF’s security system and how it can be used in non-XAF .NET apps powered by XPO.

The first example was a Console application that reads data protected by current user permissions and outputs the "Protected content" placeholder instead of secured data values.

In our next example, we’ll discuss DevExtreme + ASP.NET Web API OData. Before we do, however, we wanted to summarize some of the reasons we think you should consider XAF’s security system in your next .NET application.

Target Audience & Scenarios

• XAF developers who create non-XAF .NET apps and want to reuse existing data models and Security System settings (users, roles and permissions) stored in an XAF application database. Based on experience, XAF customers often create custom Web and mobile UI clients with ASP.NET MVC, DevExtreme; backend servers with ASP.NET Web API/OData or Console, Windows Service, WCF apps for various administrative tasks (data modifications, report generation, scheduled workflows).

• Non-XAF developers who create standard line-of-business (LOB) apps with login, logout forms and security related functionality for any .NET UI technologies like WinForms, WPF, ASP.NET (WebForms, MVC 5, MVC Core, Razor Pages) and .NET server technologies like ASP.NET Web API/OData, WCF, etc. Yet more use-cases with Blazor & Xamarin.Forms (Android, iOS, UWP) UI technologies may come when XAF v19.2 supports .NET Standard 2.0. 

Pain Points

Developers often face the following difficulties when creating security systems:

• Getting security right: safe, fast, up-to-date, flexible, and database agnostic. Ready-to-use middleware libraries like ASP.NET Core Identity or Identity Server can be difficult to configure or offer unnecessary functionality.

• LOB app developers want to save time and do not want to implement complex security memberships and authentication/authorization algorithms from scratch. For instance, filtering protected data against the current user’s access rights or checking if the current user is allowed to delete records.

• Access right customization (runtime). While certain technologies like ASP.NET simplify authentication and basic authorization with built-in design time APIs, it is difficult to build a flexible and customizable security system (allowing users to customize the system once the app is deployed).

The XAF Security System

The primary XAF security system features used in line-of-business applications across supported platforms include:

1. Role-based access control with multi-database permission storage.

1.1. Access control permissions linked to roles and users that can be stored in more than a dozen popular data stores powered by the XPO ORM (including popular RDBMS like SQL Server, Oracle, PostgreSQL, MySql, Firebird, XML and "in-memory" stores).

• Type permissions grant Read, Write, Create, and Delete access to all objects that belong to a particular type.
• Object Permissions work in conjunction with Type Permissions and grant access to object instances that fit a specified criterion.
• Member Permissions grant access to specific members unconditionally or based on a criterion.

1.2. Powerful and easy-to-use APIs to configure users, roles and permissions in code or visually in XAF apps.

1.3. Support for extensions or replacement with fully custom user, role, and permission objects to meet the needs of your business domain or address various integration scenarios.

2. Authentication.

2.1. Built-in authentication types: Forms (user name/password), Active Directory (Windows user) and Mixed (several authentication providers).

2.2. A modern and secure algorithm for password generation and validation.

2.3. Support for extension or replacement with custom authentication strategies and logon parameters. For instance, our popular example shows how to use OAuth2 with Google, Facebook or Microsoft authentication providers.

3. Authorization.

3.1. Just two code lines to read secure records filtered against a logged user (role and permission based). When you set up SecuredObjectSpaceProvider, you can create an unlimited number of secure data contexts - your data query and modification APIs will remain unchanged. A bit more code is required to connect a non-XAF client to the Middle-Tier application server.

3.2. Fine-grain access control for base and inherited objects, one to many and many to many object relationships, individual columns with or without criteria (example: can read the Full Name field, but cannot see and modify Salary) and specific object instances only.

3.3. Straightforward APIs to check CRUD or custom access rights for UI element customizations. With this, you can hide or mask protected grid columns, editors in detail forms, and disable menu toolbar commands like New, Delete, Edit, etc.

3.4. Security permission caching for the best possible performance. Two built-in Permission Policies determine the security system’s behavior when explicitly specified permissions for a specific type, object, or member do not exist.

3.5. Proven in production environments. DevExpress Support, comprehensive documentation, examples and a diagnostic tool are at your service to troubleshoot complex security permission configurations.

This is part 2 of a series of posts designed to explain XAF’s security system and how it can be used in non-XAF .NET apps powered by XPO. If you are new to XAF’s security system or to this blog series, please review some of the reasons we think you should consider XAF’s security system in your next .NET application.  

Our new exampleconsists of an ASP.NET Core Web API/OData v4 service on the server and the DevExtreme Data Grid UI on the client. The app starts with a login form and then displays a data grid with “protected” records for the logged user.

Future Plans

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 but I will save a more in-depth discussion for a later post.

As of last month, we officially canceled XAF's React-based SPA UI project. We have made the decision to focus our efforts on Blazor going forward.

We asked many XAF users for feedback and almost univerally, most felt that Blazor was indeed the right path forward. Since our ASP.NET team is also fully committed to the Blazor platform, we believe Blazor represents our best long-term option. Truth is that we seriously considered Blazor a year ago, but unfortunately it was not in the best possible state at that time.

We can no longer ignore the value Blazor brings to the table for our .NET user base. We appreciate all the wonderful React-related feedback you've given us over the last twelve months and though cancelling a 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.

Benefits of Blazor for You and DevExpress 

Though waiting another year for a Blazor UI is not the best news, our decision to pursue this new direction brings with it a number of benefits:

• XAF v19.2 will include .NET Standard 2.0 Nuget packages. This helps the Security APIs in Non-XAF apps and allows us to address more usage scenarios for both XAF and non-XAF customers.
• Blazor better fits the long term needs of our .NET users and those with little or no JavaScript, HTML and CSS experience. 
• Blazor has fewer moving parts and a simpler architecture than our React SPA UI (DevExtreme React components are wrapped with a custom written UI scaffolding framework that works on top of XAF's server-side Application Model and View-based infrastructure).
• Blazor provides simpler development flow - one that is familiar to WinForms and ASP.NET devs.
• Our initial impression is that Blazor will allow us to add features more quickly and is easier to maintain. For instance, one developer can create a basic MainDemo-like app with list and detail forms in only 5 days with Blazor server-side. 
• Blazor provides better performance than ASP.NET WebForms apps, because of its 'virtual DOM'-based UI updates (produces less traffic (bytes)). In our early tests, Blazor server-side spike performance is comparable to our SPA UI demos. Additionally, Blazor does not have issues with slow initial build (due to hundreds of megabytes in the node_modules folder). 

To Client-side, or Server-side, that is the Question.

As of this moment, our former SPA UI team is conducting final tests and we'll soon know whether to pursue Blazor client-side or Blazor server-side. Blazor client-side hosting mode supports offline and better scalability. Blazor server-side mode is much more mature, easier to use and much faster in our syntethic tests. Needless to say, we don't want customer apps (with hundreds of business classes and controllers) to load slowly with Mono inside the browser, especially on low power mobile devices.

The race continues and no obvious winner has emerged as of yet. I will announce who wins our Blazor client-side vs server-side shootout as soon as I am able. Please stay tuned.

We are two months away from our next major update (v19.2). The purpose of this post is to share our progress and give XAF users the opportunity to test new functionality before we wrap up our current dev cycle.

XAF is part of the Universal Subscription. Active Universal subscribers are entitled to download and install this Early Access Preview. If you currently own an active DXperience Subscription, you can test the features described herein by logging onto the DevExpress Download Manager and installing this build in trial mode. Once you do, please take a moment to tell us whether these new features address your business needs. This will help us fine-tune our code before official launch. 

.NET Core 3 Desktop SDK Support in WinForms Apps

To download and test XAF's WinForms Main Demo for .NET Core 3.0 Desktop, please refer to this knowledge base article. We are still working to finalize our unit and functional tests for the final release.

.NET Standard 2.0 Support for Platform-Agnostic Modules

These core libraries only provide non-visual APIs and do not offer a ready-made UI (like XAF modules for WinForms and WebForms): 

• DevExpress.ExpressApp | DevExpress.ExpressApp.Xpo | DevExpress.ExpressApp.Objects | DevExpress.ExpressApp.Images.
• DevExpress.Persistent.Base | DevExpress.Persistent.BaseImpl.
• DevExpress.ExpressApp.Security | DevExpress.ExpressApp.Security.Xpo.
• DevExpress.ExpressApp.Validation | DevExpress.ExpressApp.ConditionalAppearance
• DevExpress.ExpressApp.AuditTrail | DevExpress.ExpressApp.CloneObject.
• DevExpress.ExpressApp.Kpi | DevExpress.ExpressApp.StateMachine | DevExpress.ExpressApp.ViewVariantsModule.

Security System in non-XAF .NET Apps (Powered by XPO)

We’re doing our best to explain XAF’s security system and how it can be used in non-XAF .NET apps powered by XPO. 

Please check our new WinForms CRUD demo and tutorial - the most popular configuration based on a hundred of blog comments and survey responses!

In addition, please review our updated Console and ASP.NET Core Web API/OData v4 + DevExtreme apps.

Changes to XAF's SPA UI Strategy: The Future is Blazor 

As you may already know, we officially canceled XAF's React-based SPA UI project. We’ve made the decision to focus our efforts on Blazor.

ASP.NET WebForms Spreadsheet Editor

XAF's Office module now includes the DevExpress WebForms Spreadsheet control. You can use it to display and edit Excel documents stored in byte array properties of your business objects.

ASP.NET WebForms Batch Edit Support for Reference & ImmediatePostData Properties in ASPxGridListEditor

We now support reference and ImmediatePostData properties in ASPxGridView's Batch Edit mode - one of the most popular customer requests for our WebForms UI! 

To learn more about this new feature, please read this sample on GitHub.

Note: Our primary focus in 2020 will be on XAF’s Blazor UI but we will do what we can to address the needs of those reliant on our ASP.NET WebForms UI. 

Asynchonous Method Support in IObjectSpace

To learn more about the new IObjectSpaceAsync inteface and custom async operations in WinForms apps, please read this knowledge base article and respond to a few questions from the R&D team.

Improved Usability of Layout Groups in WinForms & WebForms

We replaced the IModelLayoutGroupWeb.IsCollapsibleCardGroup and IModelLayoutGroupWeb.IsCardGroupCollapsed properties with new platform-agnostic options: IModelLayoutGroup.IsCollapsibleGroup and IModelLayoutGroup.IsGroupCollapsed. This was necessary to implement a popular user request - collapsible layout groups for WinForms.

Performance & Stability Enhancements (Design-Time)

With this update, XAF's Model Editor, Application & Module Designers start faster and require less memory. We have done the impossible - we reimplemented Visual Studio's ITypeDiscoveryService, because its GetTypes method caused problems, especially for complex apps.

For more information, please read this knowledge base article.

Breaking Changes

Before you migrate and test existing projects, we ask that you read XAF's breaking changes document.

Your Feedback Matters!

I hope this bit of news was not buried beneath our EAP announcements last week.

Please check our new WinForms CRUD demo and tutorial to learn about our most popular configuration (based on hundreds of blog comments and survey responses).

This represents existing functionality - is available right now in XAF v19.1 (and older versions). The new v19.2 release adds .NET Standard 2.0 support - helpful for developers who create cross-platform non-XAF .NET apps and libraries.  

Our next example will be for ASP.NET WebForms. Though mature technology, WebForms remains highly popular and will likely remain relevant over the coming years. As always, we look forward to your questions or suggestions. 

Interesting Support Tickets

eXpressApp Framework

• Run an XAF WinForms application under .NET Core 3.0 using Microsoft.NET.Sdk.WindowsDesktop SDK (T724892)
  
• Display a confirmation window when switching between tabs and when the current object contains changes (T807662)
• Display a custom Action on a Logon form (T804750)
• Customize default settings for the Report Wizard in Reports V2 Module (T806051)
• Add an Action to the Rich Text Editor context menu in an ASP.NET application (T800698)
• Check if a user has permission within a business class (T803438)
• Avoid an exception when opening the Model Editor in Visual Studio when your project references a .Net Standard 2.0 library (T802380)
• Important notes about sharing .NET Standard 2.0 and .NET Core 3.0 Desktop libraries that rely upon DevExpress APIs (T808990)
• Recommendations for using associations between master and child objects (T807002)

eXpress Persistent Objects

Documentation Updates

• The next set of examples designed to describe XAF’s most popular APIs is ready: ActionBase.QuickAccess | SingleChoiceAction.ItemType | FilterController.FullTextFilterAction | NewObjectViewController.NewObjectAction | XPObjectSpace.CreateNestedObjectSpace | Frame.GetController<ControllerType> | IObjectSpace.Committing | IObjectSpace.GetObject | ShowViewStrategyBase.ShowViewInPopupWindow | IFileData.LoadFromStream | IFileData.SaveToStream | LookupEditorModeAttribute
• The Asynchronous Method Support in IObjectSpace feature we announced in our previous blogpost is fully documented for XPObjectSpace: CommitChangesAsync | EvaluateAsync | GetObjectAsync | GetObjectByKeyAsync | FindObjectAsync | PreFetchAsync
• We clarified the difference between use of DevExpress.ExpressApp.DC.AggregatedAttribute and DevExpress.Xpo.AggregatedAttribute.
• Best practices: defining your Business Objects in applications with eXpress Persistent Objects and Entity Framework: Define the Data Model and Set Initial Data.
  

Have you come across an interesting support ticket? Share it with the DevExpress developer community below.

Interesting Support Tickets

eXpressApp Framework

• Use the XafApplication and IObjectSpace instances in a Workflow Activity (T810806)
• Add a SimpleAction to NavBar and execute this Action when clicking it (T811687)
• Set focus on an editor in a pop-up window in an ASP.NET application (T688173)
• Expand a lookup editor when a user changes another property value (T817093)
• Аpply a filter to a non-persistent List View (T814100)
• Display a custom confirmation dialog on appointment deletion (T814447)
• Notify users about changes in a database that require attention (T808911)
• Specificity of using EnableAutoTabOrder with custom TabIndex and AllowFocusReadOnlyEditors (T815157)

eXpress Persistent Objects

• Prefetch properties declared in a descendant class (T819974)
• Ways to invoke a stored procedure that contains a dot symbol in its name (T810630)
• Use of CancellationToken in applications with XPO v19.1 and the Oracle ADO.NET provider causes a memory leak (T812026)

Documentation Updates

.NET Core 3 and .NET Standard 2 Support

• XAF: .NET Core 3.0 Support in XAF WinForms Applications | Port an Existing XAF Application to .NET Core 3.0 | .NET Standard 2.0 Support for Platform-Agnostic Modules
• XPO: .NET Core 3.0 and .NET Standard 2.0 Support | Getting Started with .NET Core

Custom Aggregates

We are working on documentation for our new feature you can try with the v19.2 Beta release: CustomAggregateCollection | CustomAggregateEvaluationContext<T> | ICustomAggregate | ICustomAggregateConvertibleToExpression | ICustomAggregateFormattable

Get more information on this feature in our What's New (v19.2 Beta) overview.

Best Practices

All examples in our documentation use nameof instead of hardcoded API names.

Community News

• The eXpand Framework, managed by Apostolis Bekiaris, released almost 10 new free and low-dependency modules for XAF since we wrote about it in July: http://xaf.expandframework.com/. I want to highlight the RefreshView and GridListEditor packages: the first refreshes a View periodically based on the Application Model's option and the second contains GridListEditor extensions. All the modules are small, include documentation, and ship with Azure unit tests. Please check them out and let us know what you think.
• A new version of XAFARI with full support for XAF v19.1.6 is available (DevExpress updates are slightly ahead of XAFARI versions). As you may know, Galaktika Soft has been providing paid reusable XAF modules with documentation and support services for more than 5 years.
• Joche Ojeda published a YouTube video and GitHub sample that demonstrate how a custom IDataStore implementation can be used to feed a Xamarin Forms application with data from an XAF application using the same XPO data model. 

I realize you are all busy, but if you have a moment, I’d love your feedback on our new ASP.NET WebForms CRUD demo and its step-by-step tutorial. The new demo helps demonstrate use of XAF's Security System APIs for the WebForms platform.

Ready-To-Use Login, List and Detail Forms for Your Next WinForms, DevExtreme and ASP.NET Apps

Even if you do not plan to use XAF and XPO in your apps, you can save time if you copy and modify these free form templates. They are now High DPI-ready, use SVG images and now ship with a more polished UI/UX. 

What's Next

Here's this month's XAF-related tips & tricks. If you have a support ticket you'd like to share with the XAF developer community, feel free to post a link in the comment section below.

Interesting Support Tickets

Core/General

• Sort a List View against a calculated property in Server Mode with Entity Framework (T817248)
• Display the DashbordData object in a Detail View instead of a Dashboard View (T822738)
  
• Allow administrators to impersonate users or log in using their account without entering credentials (T819870)
  
• Use custom logon parameters and strategies for multiple authentication providers in a non-XAF application (T826060)
  
• Implement a property in a base class and calculate the property value differently in descendants (T824591)
  
• Extend a list of fields available in a Mail Merge template with fields of a reference property type (T825194)
  
• Use the results of the Session.ExecuteSproc method as XtraReport's data source (T825112)
  

WinForms

• Color DetailView editors (that require a value) based on Validation module rules (T820939)
• Expand the Lookup Property Editor when a user changes an associated object property (T817093)
• Add the Taskbar Assistant component in an XAF WinForms application (T826190)
  
• XAF WinForms .NET Core 3 applications don't support the Workflow Module (T827488)
  

Web

• Change an ASP.NET Property Editor's caption at runtime (T820822)
  
• Change navigation item caption based on the number of non-viewed objects in a List View (T822113)
  
• Update a calculated property value in a List View when inline editing is enabled in an ASP.NET application (T821910)
• Use an XAF business model with appearance and validation rules in a non-XAF ASP.NET Core 3 application (T825383)
  
• Implement OAuth authentication and display an external login page instead of the default XAF login page (T825001)
  
• Add a search panel to the navigation control (T828621).

Recently Resolved Issues

• Core - Solution Wizard creates wrong content for the Error.aspx page (T826111)
• Core - Built-in XAF context menus for the TreeList are overridden with the Expand/Collapse menu of the underlying control (T819574)
• Core - ObjectSpace may silently return no objects (even though the database contains all the data) if the corresponding object type is not registered for ObjectSpaceProvider (T828300)
  
• XPO for .NET Core 3 Desktop (from the DevExpress.WindowsDesktop.* NuGet packages) does not include Dependency Injection-related functionality (T825717)
  

Documentation Updates

Custom Aggregates in Criteria Language

See our new Custom Aggregate Functions article and the How to: Implement and Use Custom Aggregate Functions step-by-step tutorial.

Office Module Updates

We reworked and extended the structure of our Office Module documentation.

• How to: Access the Rich Text Editor Controls | How to: Customize the Rich Text Property Editor
• How to: Access the Spreadsheet Controls | How to: Customize the Spreadsheet Editor

Non-Persistent Objects

We collected and described additional ways to display non-persistent or proxy objects in a Detail View: How to: Display a Non-Persistent Object's Detail View 

Your Feedback Matters

We appreciate your feedback and, as always, look forward to your comments.

Here is our first XAF Blazor (Server Side) demo. It demonstrates straightforward CRUD usage scenarios. Feel free to test its capabilities within a modern desktop or mobile browser.

https://demos.devexpress.com/XAF/BlazorDemo

How It Works

using System;
using DevExpress.Xpo;
using DevExpress.Xpo.Metadata;
using DevExpress.ExpressApp.DC;
using DevExpress.Persistent.Base;
using DevExpress.ExpressApp.Model;
using DevExpress.Persistent.BaseImpl;

namespace BlazorDemo.Module.BusinessObjects {
    [DefaultClassOptions]
    [XafDisplayName("Note")]
    [XafDefaultProperty(nameof(Subject))]
    public class DemoNote : BaseObject {
        public DemoNote(Session session) : base(session) { }
        private string _Subject;
        public string Subject {
            get { return _Subject; }
            set { SetPropertyValue<string>(nameof(Subject), value); }
        }
        private DateTime _CreatedOn;
        [ModelDefault(nameof(IModelCommonMemberViewItem.AllowEdit), "False")]
        [ValueConverter(typeof(UtcDateTimeConverter))]
        public DateTime CreatedOn {
            get { return _CreatedOn; }
            set { SetPropertyValue<DateTime>(nameof(CreatedOn), value); }
        }
        private DateTime _LastModified;
        [ModelDefault(nameof(IModelCommonMemberViewItem.AllowEdit), "False")]
        [ValueConverter(typeof(UtcDateTimeConverter))]
        public DateTime? LastModified {
            get { return _LastModified; }
            set { SetPropertyValue<DateTime?>(nameof(LastModified), value); }
        }
        private string _Owner;
        [ModelDefault(nameof(IModelCommonMemberViewItem.AllowEdit), "False")]
        public string Owner {
            get { return _Owner; }
            set { SetPropertyValue<string>(nameof(Owner), value); }
        }
        private string _Description;
        [Size(SizeAttribute.Unlimited)]
        public string Description {
            get { return _Description; }
            set { SetPropertyValue<string>(nameof(Description), value); }
        }
        public override void AfterConstruction() {
            base.AfterConstruction();
            CreatedOn = DateTime.Now;
            LastModified = DateTime.Now;
            Owner = "BLAZOR Demo User";
        }
        protected override void OnSaving() {
            base.OnSaving();
            if(!Session.IsNewObject(this)) {
                LastModified = DateTime.Now;
            }
        }
    }
}

It uses eXpress Persistent Objects (XPO), but we will support Entity Framework in the future. For more information on how XAF works, refer to Getting Started.

Future Plans

By the end of 2020, we hope to give XAF users a stable platform on which to build Blazor-powered apps (with full CRUD capabilities and core modules like Security and Validation). As you’d expect, usage scenarios will be partly driven by the scope and breadth of the DevExpress Blazor product line. To help clarify our vision, we will build a Blazor demo inspired by its ASP.NET WebForms counterpart (MainDemo) - expect more updates from us in the coming months.

Blazor Server Today, Blazor WebAssembly is for the Future

As you know, our decision was relatively simple: Blazor Server is ready for production while Blazor WebAssembly is in preview (learn more from Microsoft). Blazor WebAssembly is also hampered by a few performance issues.

In addition to performance, Blazor WebAssembly involves more complicated development paradigms for existing XAF users. For instance, you need to consider client and server communications, use asynchronous APIs with IObjectSpaceAsync, ActionBase.ExecuteAsync, etc.

Anyway, we will certainly monitor the progress of Blazor WebAssembly and reconsider our strategy when necessary. So far, we have not done anything that would prevent a potential switch from one hosting mode to another.

Your Feedback Matters

To engage us and discuss XAF’s vision, roadmap and technical requirements, please use our private XAF discussion forum (exclusively for Universal customers). The forum also includes a known issues list for this pre-alpha release.

Feel free to comment below or email us at xafteam@devexpress.com for more information.

Here is our ASP.NET Core MVC demo and step-by-step tutorial for XAF’s user authentication and group authorization API. Many of you asked us to deliver this demo – thank you for your feedback and your continued engagement.

If you’re using Xamarin, WPF or Blazor, please be patient with us – we will produce user authentication and group authorization demos for these platforms shortly.

We also hope to update our samples to .NET Core 3.0 where applicable. And finally, we do expect to refactor and simplify demo code and instructions. For instance, instead of IsGranted calls, which may accept many parameters, we will introduce CanRead, CanWrite and other shortcuts in v19.2.4. XAF WinForms and WebForms developers will benefit from these usability enhancements as well.

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

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

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 (S30514, S30735 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 (T486427, T510338, T695631).

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.

As you probably know, we are building XAF's next-gen Web and Mobile UI with the DevExpress Blazor components. At this stage, we use the Blazor Server Side hosting model because it is stable and fast (we will look at Blazor WebAssembly again when it is out of preview).

If you are interested in our new Web and Mobile UI, please take a look at our updated web demo: https://www.devexpress.com/go/XAF_Blazor_Demo.aspx. This updated demo shows-off familiar XAF property editors and even additional extra modules: File Attachments, View Variants and Audit Trail.

What's Next?

Your Feedback Matters

Functional Tests

We continue to use our cross-platform EasyTest engine for functional testing. Chrome or FireFox web browser interaction is powered by Selenium.

If you have Google Chrome installed on your desktop, you can run automatic tests for our online Blazor demo with Visual Studio or the command prompt - no special configuration is required. For more information, refer to the following KB article: How to use EasyTest and Selenium WebDriver to create functional tests for XAF's Blazor UI with C#, VB.NET or a human-readable scripting language.

The following are supported:

1. Functional tests with C# or VB.NET (for developers).

using DevExpress.ExpressApp.EasyTest.BlazorAdapter;
using DevExpress.ExpressApp.EasyTest.BlazorAdapter.TestControls;
using DevExpress.ExpressApp.EasyTest.BlazorAdapter.Utils;
using NUnit.Framework;

namespace MainDemo.Blazor.FunctionalTest {
    public class TakeScreenshortTests : FunctionalTestBase {
        public TakeScreenshortTests() {
            TestSettings.DefaultApplicationUrl = "https://demos.devexpress.com/XAF/BlazorDemo/";
        }
        [Test]
        public void StartPageScreenshot() {
            CompareScreenshot.Exec(TestSettings.CombineWithCWD(@"..\..\Images\MainDemo.png"), Browser.GetImage());
        }
        [Test]
        public void DeatailViewScreenshot() {
            var mainListView = new MainListView(Driver);
            mainListView.Grid.RowClick("Hewitt Aiello");
            CompareScreenshot.Exec(TestSettings.CombineWithCWD(@"..\..\Images\ContactMainDemo.png"), Browser.GetImage());
        }
        [Test]
        public void CRUD() {
            var contactsListView = new MainListView(Driver);
            contactsListView.Toolbar.FindControl("New").Act(null);
            var contactDetailView = new MainDetailView(Driver);
            ((IControlText)contactDetailView.Form.FindControl(TestControlType.Field, "First Name")).Text = "TestName";
            contactDetailView.Toolbar.FindControl("Save and Close").Act();
            contactsListView = new MainListView(Driver);
            contactsListView.Grid.RowClick("TestName");
            contactDetailView = new MainDetailView(Driver);
            contactDetailView.Toolbar.FindControl("Delete").Act();
            wait.Until(BlazorAppResponseAwaiter.IsAlertPresent);
            var dialog = new DialogTestControl(Driver);
            Assert.AreEqual("You are about to delete the selected record(s). Do you want to proceed?", dialog.Text);
            dialog.Act("Yes");
            wait.Until(SeleniumUtils.ElementExists(GridTestControl.ByGrid));
            contactsListView = new MainListView(Driver);
            Assert.AreEqual(0, contactsListView.Grid.WebElement.FindElements(GridTestControl.ByRowByValue("TestName")).Count);
        }
    }
}

2. Functional tests with human-readable scripts (for non-developers).

#Application MainDemoBlazor_Chrome

*Action New
*FillForm
 First Name = TestContact
*Action Save and Close

*ProcessRecord 
 Full Name = TestContact

*Action Delete

*HandleDialog
 Respond = Yes
 Message = You are about to delete the selected record(s). Do you want to proceed?

!ProcessRecord 
 Full Name = TestContact

Unit Tests

Thanks to XAF's modular architecture and mocks, we can keep our unit tests as lightweight as possible. Unit tests for Blazor UI are no different than XAF tests for WinForms or WebForms. Consider the following test cases: 

1. Test whether a Controller's Action is active in DetailView and ListView.

#if DebugTest
using DevExpress.ExpressApp.Base.Tests;
using DevExpress.ExpressApp.Blazor.SystemModule;
using DevExpress.ExpressApp.Tests.Blazor.Helpers;
using NUnit.Framework;

namespace DevExpress.ExpressApp.Tests.Blazor.SystemModule {
    [TestFixture]
    public class ModificationsControllerTests : BaseDBTest {
        [Test]
        public void TestUpdateActionState() {
            DetailView detailView = new TestDetailViewFactory(this).CreateView<TestPersistentObject>(true);
            BlazorModificationsController modificationsController = new BlazorModificationsController();
            modificationsController.SetView(detailView);
            Assert.IsTrue(modificationsController.SaveAction.Active["OnlyForDetailView"]);
            Assert.IsTrue(modificationsController.SaveAndCloseAction.Active["OnlyForDetailView"]);
            Assert.IsTrue(modificationsController.SaveAndNewAction.Active["OnlyForDetailView"]);
            Assert.IsTrue(modificationsController.CancelAction.Active["OnlyForDetailView"]);

            ListView listView = new TestListViewFactory(this).CreateView<TestPersistentObject>();
            modificationsController = new BlazorModificationsController();
            modificationsController.SetView(listView);
            Assert.IsFalse(modificationsController.SaveAction.Active["OnlyForDetailView"]);
            Assert.IsFalse(modificationsController.SaveAndCloseAction.Active["OnlyForDetailView"]);
            Assert.IsFalse(modificationsController.SaveAndNewAction.Active["OnlyForDetailView"]);
            Assert.IsFalse(modificationsController.CancelAction.Active["OnlyForDetailView"]);
        }
//...
}

2. Test whether a boolean property editor has localized values in the underlying control based on the Application Model.

//...
[Test]
public void SelectedItemTest() {
    ModelPropertyEditorImpl model = new ModelPropertyEditorImpl("Bool");
    model.CaptionForFalse = "CaptionForFalse";
    model.CaptionForTrue = "CaptionForTrue";
    BooleanPropertyEditor propertyEditor = new BooleanPropertyEditor(typeof(TestObjectWithNullableProperties), model);

    propertyEditor.ComponentValue = null;
    Assert.IsNull(propertyEditor.SelectedItem);
    Assert.IsNull(propertyEditor.ComponentValue);

    propertyEditor.ComponentValue = true;
    Assert.AreEqual(model.CaptionForTrue, propertyEditor.SelectedItem.Caption);
    Assert.AreEqual(propertyEditor.ComponentValue, propertyEditor.SelectedItem.Value);

    propertyEditor.ComponentValue = false;
    Assert.AreEqual(model.CaptionForFalse, propertyEditor.SelectedItem.Caption);
    Assert.AreEqual(propertyEditor.ComponentValue, propertyEditor.SelectedItem.Value);
}
//...

Future Plans

Ultimately, we will release all required assemblies with helper/mock classes (like TestDBTest, TestDetailViewFactory, BlazorAdapter, etc.) - all to reduce the time needed to write unit and functional tests with XAF.

If you have problematic scenarios that you want us to document, please leave comments to this post - thank you in advance.

Before I detail XAF’s 2020 Roadmap, my thanks to everyone who shared feedback/thoughts last year. Your contribution to XAF’s evolution is appreciated.

The following list outlines the features/capabilities we expect to introduce in the eXpressApp Framework (XAF) this year.

Blazor UI

WinForms UI

• 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 want to enable enhanced WinForms Filter and Expression editors in the Model Editor and within built-in List and Property Editors (v20.1).
• We want to rewrite our Tree List Editors module and support inplace data editing, better filtering options and more features (S30514, S30735 S38121) based on user feedback (v20.2).
  

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.

Housekeeping & Core

• 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, Visual Studio vNext, .NET 5 and C# 8.0 features like Nullable Reference Types  (v20.1, 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 (T486427, T510338, T695631).
• You can expect further performance enhancements to the Application Model and other core sub-systems. For  instance, removing static XafTypesInfo dependencies and locks in ModelNode may result in faster app startup and unit tests as well as greater scalability for Blazor apps.

Security System: User Authentication and Group Authorization API

Your Opinion Counts

As always, we look forward to your comments and questions. Please share your thoughts below or email xafteam@devexpress.com.

Interesting Support Tickets

Miscellaneous

• Specify visible object properties in CriteriaPropertyEditor (T188284)
  
• Implement JSON Web Token authentication in non-XAF apps with the Security System (T833845)
• Change the Application Model inside functional tests (T838622)
  
• Ways to create end-user documentation for XAF apps (T845788)

Usability & Performance Enhancements

• The Model Editor's image picker now remembers filters, window size and position between app execution (T817983).
• EasyTest for WinForms apps no longer requires administrative privileges (T836194).
• Security apps with Active Directory authentication no longer display a confusing ChangePasswordOnFirstLogon checkbox (T848218).
  
• To help improve performance, WinForms apps no longer check database schema every 5 minutes (T848947).
• XPO v20.1 supports Microsoft.Data.SqlClient.dll.
  
• XPO v20.1 now deletes objects with aggregated collections much more quickly. For instance, for 500K nested objects it's ~5x faster than in v19.2 (10.2 sec vs 46.8 sec).

Simplified Access to List View's Objects

How to: Access Objects Selected in the Current View: This article now demonstrates a way to access business object wrappers via the IObjectRecord interface for different List View data access modes.

User-Friendly URLs

How to: Print a Report Without Displaying a Preview: This approach now supports the user-friendly URLs mechanism.

Showcase Your Apps on DevExpresss.com

Our recent enhancements to user authentication and group authorization demos include the following:  

• .NET Core 3.0+ versions of WinForms, ASP.NET Core MVC, Web API/OData v4 + DevExtreme apps.
• New non-XAF Blazor Server demo and tutorial based on DevExpress Blazor components and XAF's security system APIs.

• New extension methods CanXXX for the SecurityStrategy class (where XXX is Read, Write, Create, Delete, Navigate) that replace complicated IsGranted calls with many parameters.

  //BEFORE
  SecuritySystem.IsGranted(
      new PermissionRequest(ObjectSpace, typeof(DemoTask), 
         SecurityOperations.Write, selectedObject, nameof(DemoTask.Status)
      )
  );
  
  //AFTER:
  security.CanWrite(selectedObject, nameof(DemoTask.Status));

  We simplified XAF and non-XAF demo code and help topics accordingly. XAF WinForms and WebForms developers will benefit from these usability enhancements as well. For more examples, see our MainDemo v19.2.6 ("c:\Users\Public\Documents\DevExpress Demos 19.2\Components\eXpressApp Framework\MainDemo\CS\MainDemo.Module\Controllers\TaskActionsController.cs").
• New extension methods CanXXXByUser and CanXXXByRole for the SecurityStrategy class. These extension methods help query access rights for required user and role objects even if you are not logged in under them within a secured application. Use cases include custom UI or diagnostic tools designed to display effective permissions for certain users (T413260, T826065, T552175). More documentation and code examples are coming soon.

Please Help Us Decide on Xamarin, Blazor WebAssembly, WPF and ASP.NET MVC 5 Demo Apps

Based on user surveys and blog comments, interest for highlighted platforms was not very high. Also, many users wanted to see WinForms and ASP.NET Core examples with OAuth2 - using Microsoft Office 365, Azure Active Directory or Google authentication providers (we currently display a simple Forms authentication with a login and password).

Please leave comments about the most desired platforms and use-case scenarios with our authentication and group authorization APIs. Even if you are not using XAF yet, we would love to hear from you about problematic or costly tasks associated with other security libraries such as Identity Server or ASP.NET Core. Thank you for your continued support!

Recent Feedback

I wanted to share a testimonial from David Desidera, Solution Architect at SpecTect, who successfully integrated XAF's security system APIs with a legacy WinForms app:

More than one year ago I explained to my collaborators that - in my opinion - it was possible to integrate XAF's security layer with UI interface into an existing WinForms enterprise application that was 10 years old. We successfully implemented it! It took 40 man-days of job in total instead of at least 400 if I had decided to start from scratch. You guys saved my life!!

If you are using XAF's security system APIs or simply evaluating it at present time, please share your experience below.

After the release of DevExpress Blazor UI Components v19.2.3, we updated our XAF Blazor demo, addressed a few issues and implemented some new capabilities. As always, we look forward to your comments and questions. 

• Theme Selector with 20+ Bootstrap themes: At this stage, we’ve tested the default Office White theme (minor issues are expected for other themes).
  
  
  
• Optimistic Concurrency Control: Includes the ability to merge and discard changes.
• 'Edit' button for aggregated objects and a Clear button for nullable editors.
• Partial data loading for root List Views (like Server Mode).
• Page Size selector in List Views.
• List View records now open via a single click instead of the in-place 'Open' button.
• Previous known issues were resolved:
  1. The Filter by Text command is now case-insensitive;
  2. List View rows can be grouped by reference properties;
  3. New objects are immediately added to List Views.

What's Next?

We are presently working on the following new features:

• Simple Form-based 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).
• A "compact" toggle for all themes in the Theme Selector (many customers wanted more compact themes for the Web). We will also polish remaining themes for XAF layouts by v20.1.

For more information on what we have planned for XAF Blazor, please refer to the eXpressApp Framework - 2020 Roadmap.