WPF & WinUI - 2021 Roadmap

We hope you are doing well. Thank you for your continued support. We appreciate the faith you’ve placed in our XAML-based desktop product line.

In this post, I’ll summarize WPF-related features we expect to ship in the coming year and share our plans for Microsoft’s WinUI platform. As you know, WinUI is Microsoft’s next-gen desktop dev platform and though it has yet to fully mature, we are excited about its long-term potential.

As always, should you have questions, feel free to post comments below. We will be happy to follow-up.

Table of Contents

• WinUI 2021 Roadmap
  • March Release
  • WinUI 3 for UWP vs WinUI 3 for Desktop (Win32)
• WPF 2021 Roadmap
  • Key Priorities
  • .NET Core and .NET
  • ARM64 Support
  • MVVM
  • XAML Customization
  • Performance
  • Windows 10 Dark Theme
  • Charting & Analytics - Additional Features
  • Office UI Controls & File API - Additional Features
  • Reporting - Additional Features
• Your Feedback Matters

WinUI 2021 Roadmap

WinUI March Release

In a couple of weeks, we will release 20 new WinUI 3 components (with focus on modern UI paradigms, performance enhancements, and an API consistent with the WinUI platform itself). Our initial WinUI release will include the following controls:

• Data Grid
• Charting
• Scheduler
• Ribbon Toolbar
• Data Editors
• Gauges and Indicators
• Barcode
• MVVM Framework

Our March WinUI release will be available free of charge. We will also update our WPF Subscription to include all DevExpress WinUI component libraries (now and into the future).

Please stay tuned for more information on our WinUI product line - We expect to publish a detailed blog post in the coming weeks (this post will include information on upcoming products/enhancements, including our WinUI TreeList control).

WinUI 3 for UWP vs WinUI 3 for Desktop (Win32)

DevExpress WinUI controls will be available for use within WinUI 3 for UWP apps. Since WinUI 3 for desktop (Win32) requires optimization, we have chosen not to support it at this time. We are aware that WinUI 3 for Win32 is more appealing to desktop developers and are working with Microsoft to bring DevExpress WinUI controls to WinUI 3 for Win32 apps.

WPF 2021 Roadmap

Key Priorities

The following list summarizes our WPF-related development priorities for 2021:

• Support .NET Core and new .NET releases
• Support new WPF and Windows features
• Enhance Performance
• Improve MVVM support
• Simplify XAML customization

Most of our new enhancements and features will align with these development priorities.

.NET Core and .NET

The future of WPF is with .NET Core and new versions of .NET. While support for .NET Framework is not going anywhere, we will focus significant resources on improving the developer experience within .NET Core.

.NET 6 Support

We expect to support .NET 6 when it is released in November. We will issue compatible builds a few months in advance.

XAML Designer - Suggested Actions

We decided to delay the first incarnation of Suggested Action support late last year.

In 2021, we will rework our Suggested Action implementation and enable it within Visual Studio preview builds (without affecting older versions of Visual Studio).

In addition to functionality announced previously, Suggested Action support will incorporate the following new features:

• Support for non-visual elements (Toolbar & Ribbon items, Data Grid columns).
• Additional options / settings.
• Support for nested elements (for example, TableView options will be available from GridControl).
• An Appearance tab with even more options for the most popular controls.

Visual Studio Chart Designer for .NET 5

The DevExpress Chart Designer will be a separate window invoked from within Visual Studio. It will generate charts (of any complexity) from scratch and allow you to customize existing charts via its intuitive user interface.

Visual Studio Report Designer for .NET 5

The DevExpress Visual Studio Report Designer will support apps targeting .NET 5 and higher. In addition, we expect to offer a straightforward way to migrate your reports to .NET 5.

New XAML Designer for .NET Framework

At some point, Microsoft will use its new WPF XAML designer for .NET Framework apps. We expect to support all popular DevExpress extensions within the new WPF XAML designer once it replaces the current designer.

Documentation - .NET Version Selector

We expect to improve documentation and update help topics for .NET Core and .NET 5. You will be able to switch between the Framework and .NET versions of the same help topic.

ARM64 Support

Thanks to increased popularity of ARM-based desktop devices, the WPF team at Microsoft plans to release ARM64 support in .NET 6 (or in a .NET 5 service release). A preview build with ARM64 support is available here: WPF ARM64 Support now available in .NET 6 Preview 1.

We will make certain that DevExpress WPF controls work as expected within ARM64 environments.

MVVM

DevExpress WPF controls are built with an MVVM-focused API, support popular MVVM frameworks, and ship with our own MVVM Framework. In 2021, we’ll extend MVVM support further.

Compile-Time ViewModel Generation

This experimental feature will use C# Source Generators introduced in .NET 5 to generate boilerplate code for your ViewModels at compile time. Command declarations, property change notifications, IDataErrorInfo implementation, and service support will be automatically added to a partial class linked to your ViewModel.

//manual part
[GenerateViewModel]
public partial class ViewModel {
    [GenerateProperty]
    int _count;
    [GenerateCommand]
    public void Increment() {
        Count++;
    }
}

//generated part
public partial class ViewModel : INotifyPropertyChanged {
    public event PropertyChangedEventHandler PropertyChanged;
    protected void RaisePropertyChanged(string propertyName) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    public int Count {
        get => _count;
        set {
            if (EqualityComparer<int>.Default.Equals(_count, value)) return;
            _count = value;
            RaisePropertyChanged(nameof(Count));
        }
    }
    DelegateCommand incrementCommand;
    public DelegateCommand IncrementCommand {
        get => incrementCommand ??= new DelegateCommand(Increment, null, true);
    }
}

Compile-time code generation shares benefits associated with both runtime-generated POCO ViewModels and standard ViewModelBase descendants:

• ViewModels are free of repetitive boilerplate code.
• Generated code is stored in partial classes - can be viewed and debugged easily.
• ViewModel classes are the same at design time and runtime.
• Best possible runtime performance since classes are generated in advance.

EventToCommand - Event Args Back Conversion

When passing event args to a command, you will be able to define back conversion logic and return values from a command to an event:

<dxe:TextEdit>
    <dxmvvm:Interaction.Behaviors>
        <dxmvvm:EventToCommand EventName="Validate"
                               Command="{Binding ValidateCommand}"
                               EventArgsConverter={local:ValidateEventArgsConverter} />
    </dxmvvm:Interaction.Behaviors>
</dxe:TextEdit>

public class ValidateEventArgsConverter : EventArgsConverterBase<ValidationEventArgs> {
    protected override void ConvertBack(object sender, ValidationEventArgs args, object parameter) {
        if (parameter is ValidationInfo info && info.IsValid)
            args.SetError(info.ErrorContent, info.ErrorType);
    }
    ...
}

This should simplify situations when an event expects a return value and UI-specific event args cannot be passed to a ViewModel. Examples of such events are validation, custom sorting, custom display text, etc.

Data Grid - New Command API

We expect to create command counterparts for Data Grid events that expect a return value:

<dxg:GridControl CustomColumnDisplayTextCommand="{Binding CalculateDisplayTextCommand}" />

These commands will pass a typed parameter and expose UI-independent event args to the ViewModel. This change will allow you to return values back to an event by simply modifying the command parameter at the ViewModel level:

[Command]
public void CalculateDisplayText(DevExpress.Mvvm.Xpf.CustomColumnDisplayTextArgs args) {
    args.DisplayText = GetLocalizedValue(args.FieldName, args.Value, Language);
}

The following is a list of events under consideration:

• ValidateCell
• ValidateRow
• CustomColumnSort
• CustomColumnDisplayText
• CustomUnboundColumnData
• CustomSummary
• CellValueChanging

Data Grid - MVVM Support in Virtual Sources

You will be able to implement data operations for Virtual Sources at the ViewModel level without introducing dependencies to the UI. Virtual Sources will introduce new command properties in addition to events:

<dxg:GridControl.ItemsSource>
    <dxg:InfiniteAsyncSource ElementType="{x:Type local:IssueData}"
                             FetchRowsCommand="{Binding FetchIssuesCommand}"
                             GetTotalSummariesCommand="{Binding GetTotalSummariesCommand}"
                             GetUniqueValuesCommand="{Binding GetUniqueValuesCommand}">
    </dxg:InfiniteAsyncSource>
</dxg:GridControl.ItemsSource>

Command parameters will expose a platform-independent API that allows you to pass data from the ViewModel to the Data Grid:

[Command]
public void FetchIssues(DevExpress.Mvvm.Xpf.FetchRowsAsyncArgs args) {
    args.Result = GetIssuesAsync(args);
}

Maps - MVVM Enhancements

Our new API will generate multi-point vector elements such as Polyline and Polygon from a collection of points defined at the ViewModel level.

Reporting - MVVM Enhancements and Best Practices

We expect to create examples and best practices for loading and saving reports in an MVVM application, as well as make API enhancements to simplify these scenarios.

Dependency Injection - Best Practices and Examples

We will prepare guidance on how to use Dependency Injection containers (such as Microsoft.Extensions.DependencyInjection) with the DevExpress MVVM framework.

XAML Customization

While themes and our Theme Designer offer numerous application-wide theme options, many apps require additional flexibility in this regard.

As you know, last year we extended standard appearance properties and added new appearance customization APIs for our WPF Data Editors, Data Grid, Toolbars, and Ribbon control. Customizations that once required replacement of templates or style rewrites can now be accomplished with a single property setting. Even layouts that differ from those offered by DevExpress (like the one pictured below) can now be implemented without accessing theme resources:

This year, we will extend support introduced in 2020 and address additional customization scenarios.

Appearance API Support

We will enhance the appearance API for both our WPF Pivot Grid and WPF Accordion. Our plan is to support standard appearance properties such as Background, Foreground, BorderBrush, and BorderThickness.

Appearance Tab for Suggested Actions

Our most popular WPF controls will display an Appearance tab within Suggested Actions. This tab will summarize the API needed to customize control appearance.

Performance

Startup Performance Enhancements

Our number one priority is to enhance startup performance for WPF apps with complex Office-inspired user experiences. We expect to optimize startup performance for the following UI controls in 2021:

• Spreadsheet;
• Rich Text Editor;
• Ribbon layouts with multiple pages / merging operations.

Once complete, we expect to substantially improve startup performance:

Theme Preload Enhancements

We expect to enhance Theme Preload functionality and improve startup performance for consecutive forms and dialogs within your WPF app. Here is an example of how Theme Preload can affect the loading time of a typical form with Data Grid and editors:

To achieve this objective, will introduce a synchronous preload mode option and allow applications to load all theme resources during startup (while a splash screen is displayed on-screen). Once the application is loaded, all forms that require theme resources will be initialized and will open faster.

Remote Desktop Performance Enhancements

We expect to improve our WPF product line and make certain that individual components function at the highest possible level when a WPF app is executed remotely (using tools such as Microsoft Remote Desktop Services or Citrix). We will introduce a new API to help configure applications for key Remote Desktop usage scenarios, including:

• Disable animations across the entire app;
• Free theme resources held after multiple sign in/sign out operations (common for applications executed over RDP).

TreeList - Lock Data Updates

We will introduce an API to fully lock calculations within the TreeList during data source updates. This should enhance execution performance when multiple nodes require simultaneous updates.

Charting - Lower Memory Consumption

Our new data processing engine/API will reduce our Charting library’s overall memory footprint (this change will also enhance performance because of fewer memory allocations).

Windows 10 Dark Theme

We expect to base the Dark version of our Windows 10 theme on Microsoft’s Windows Dark Mode. This new Windows 10 theme will also automatically switch between Dark and Light modes based on user preferences at the operating system level.

WPF Charting & Analytics - Additional Features

New 2D Heat Map

You will be able to create heat maps and visualize hot spots / display patterns and correlations in large data sets.

Charting - Customizable Empty Point

We expect to introduce a variable empty point visualization option. With it, you can choose how to display an empty point within your app: as a gap, as a span (like Microsoft Excel), mark it by color/a special symbol, or simply ignore it.

Maps - Direction for Line and Polyline

Lines and Polylines will display arrows indicating direction.

Maps - Area Limits

Our WPF Map control will allow you to limit the control's available map area.

Maps - Even More Bing Services

We plan to extend the pool of supported data service providers, and support services such as Traffic Layer, Fleet Management API and Distance Matrix API.

Sunburst and TreeMap - Titles and Legends

We will add title and legend elements to our Sunburst and TreeMap controls. This update will include a customization API that mirrors our WPF Chart control.

Sankey Diagram - Selection Support

End-users will be able to select individual bands in the Sankey Diagram.

Sankey Diagram - Layout Enhancements

A new LayoutAlgorithm property allows you to choose an algorithm that arranges sankey nodes. You can choose one of the predefined algorithms or create your own.

WPF Office UI Controls & File API - Additional Features

Rich Text Editor & Word Processing Document API

RC4 CryptoAPI Encryption

Our upcoming release will allow you to import and export RC4 CryptoAPI encrypted DOC files. We will use our own RC4 CryptoAPI encryption implementation to encrypt DOC files created with our API. RC4 CryptoAPI will be the default encryption method for binary files (instead of RC4 - see Breaking Change T973019).

New Document Elements

We will use our Spreadsheet Chart API to support charting across our Word processing components. You will be able to create 2-D and 3-D charts in code, apply chart styles, and format individual chart elements as needed.

ActiveX Controls

Our new APIs will allow you to access ActiveX controls in code, obtain associated properties (type, name, and ProgID), and remove these controls from a document when necessary.

Watermarks

You will be able to import and export documents with watermarks. Watermarks will be displayed, printed, and exported to PDF. In the second half of 2021, we expect to introduce new APIs to manage watermarks in code.

Table Formatting Enhancements

We will add a new table row option - “Repeat as header row at the top of each page”. You will be able to toggle this feature in code or via the Rich Text Editor's UI.

Spreadsheet Control & Spreadsheet Document API

RC4 CryptoAPI Encryption

Our upcoming release will allow you to import and export RC4 CryptoAPI encrypted XLS files. We will use our own RC4 CryptoAPI encryption implementation to encrypt XLS files created with our API. RC4 CryptoAPI will be the default encryption method for binary files (instead of RC4 - see Breaking Change T973019).

Excel 2016 Charts – Enhancements

We expect to address the following limitations related to our current Excel 2016 chart implementation:

• Implement interface elements for our Spreadsheet controls to help insert Excel 2016 charts and change chart type as necessary.

  

• Introduce support for sunburst and treemap charts. Our Spreadsheet UI controls will render these charts. You will also be able to print and export sunburst and treemap charts to PDF.

Accounting Number Format Alignment

As you may already know, if you apply the built-in Accounting number format to a cell value, Microsoft Excel will display the currency symbol on the left and numbers on the right. That’s because this format code contains an asterisk followed by a space:

_($* #,##0.00_);_($* (#,##0.00);_($* "-"??_);_(@_)

The asterisk tells Excel to repeat the space character until the cell's width is populated. We’re going to support this alignment behavior for our Spreadsheet UI controls (to replicate Microsoft Excel behavior).

Progress Indication (v21.1)

Our Spreadsheet controls will ship with a built-in Progress Bar. This Progress Bar can be used to indicate the progress of lengthy operations (file load and save operations, export to PDF and HTML, etc.).

We’ll also add an IProgress<T> parameter to the following asynchronous methods to implement progress notifications:

• Workbook.LoadDocumentAsync;
• Workbook.SaveDocumentAsync;
• Workbook.ExportToPdfAsync;
• Workbook.ExportToHtmlAsync.

API Enhancements

We plan to implement new APIs that will allow you to:

• Replace an existing worksheet picture with a new picture;
• Export a cell range to an image (available only for Spreadsheet Document API). You’ll need an active license for the DevExpress Office File API Subscription or the DevExpress Universal Subscription to use this API in production code.

Accessible PDF Export

We’re going to enhance PDF export in our Spreadsheet and Word processing products to produce accessible PDFs for use by individuals with disabilities.

PDF Document API

XMP Metadata

Our PDF Document API will allow you to embed Extensible Metadata Platform (XMP) data in your PDF document. XMP is a standard format for metadata creation, processing, and interchange.

Form Field API Enhancements

We will extend our Form Field API so you can change properties of available form field types, retrieve complex field items and change associated display text.

Digital Signature Appearance

We expect to add new APIs to generate signature appearance. You will be able to show additional information in a signature field (location, reason, signer name, etc.) together with a signature image.

WPF Reporting - Additional Features

Export To PDF - Tagged PDF

You’ll be able to produce tagged PDF documents so that impaired users can better perceive information within PDF reader applications. Our updated PDF export engine will allow you to export documents that conform to the following:

• PDF/UA standard
• PDF/A-1a, PDF/A-2a, PDF/A-3a standards (Level A conformance)

Runtime Report Generation - New Fluent API

We will engineer a Fluent API for those who prefer to create reports at runtime. Our goal is to significantly reduce the amount of code required to create tabular reports with multiple bands.

XtraReport myTablereport = ReportLayoutFluentBuilder
    .Report()
    .WithReportUnit(reportUnit: ReportUnit.HundredthsOfAnInch)
    .PageHeader(builder => {
        builder
        .Table()
        .AddRow("Company", "City", "State", "Orders", "Average Sale Amount")
        .Build();
    })
    .Detail(builder => {
        builder
        .Table()
        .AddRow(new[] { "[Name]", "[City]", "[State]", "[CustomersOrders_1][].Count()", "[CustomersOrders_1][].Avg([TotalAmount])" }, asExpression: true)
        .Build();
    })
    .Build();
}

Report Designer Enhancements

Report Design Analyzer

The DevExpress Report Designer will scan your report for changes on-the-fly and help you avoid design-related mistakes that may affect the document appearance and generated export files. We will rename the Script Errors panel to Report Design Analyzer. You will still be able to view script errors within this panel, but we will extend it with the following new capabilities:

• The panel will point you to report layout issues and list actions you can take to avoid potential errors.
• The panel will display runtime-related errors that can occur during the document creation process

The Report Design Analyzer panel will also be available within the Web Report Designer.

UX Enhancements

We will extend our Visual Studio Report Designer/Desktop End-User Report Designer and improve the report design process. Enhancements will include:

• New Smart Tag icons for both report control and the report itself.

• The Expression Editor will allow you to set up expression bindings for various report control properties directly within its dialog window.

• The Properties Panel UI will reflect a property’s data-bound state. An update will give users the ability to distinguish if a property supports data binding or if it is already bound to a data column.

• We’ll ship an updated toolbox with a new look & feel. We’ll also logically distribute report controls into sections.

• Scripts Auto-Complete functionality will be reworked and will function in a more “intelligent” manner.

Localization - Translation Strings CSV Import/Export

You’ll be able to export report localization strings to a CSV file and use it to translate report elements with the help of third-party services. You will also be able to import translations within a CSV file back to a report.

Parameters Panel Customization API

We will engineer an API that allows you to generate your own parameters panel layout based on report parameters. This new API will address the following usage scenarios:

• Customizing parameter editors
• Changing parameter editors location and size
• Changing parameter description labels location and size
• Parameter editors grouping
• Conditional visibility of parameter editors

PDF Content - Embed PDFs into Report Pages

The XRPdfContent report control will ship with a new operating mode. The control will offer the ability to scale down a single-page PDF and embed it into a report band as a picture.

Data Source Enhancements

Excel Data Source - Binding by a Sheet Index

You will be able to bind reports directly to Excel files with multiple sheets via our new ExcelWorksheetSettings.WorksheetIndex property:

ExcelDataSource excelDataSource = new ExcelDataSource(){ 
    FileName = path; 
};

// Select a required worksheet.
ExcelWorksheetSettings excelWorksheetSettings = new ExcelWorksheetSettings() { 
    WorksheetIndex = 1
};

// Specify import settings.
ExcelSourceOptions excelSourceOptions = new ExcelSourceOptions() {
    ImportSettings = excelWorksheetSettings,
    SkipHiddenRows = true,
    SkipHiddenColumns = true,
    UseFirstRowAsHeader = true
};

excelDataSource.SourceOptions = excelSourceOptions;

// Fill the data source
excelDataSource.Fill();

New MongoDB Data Source

You will be able to bind reports to a MongoDB database. The new data source will allow you to select the desired database name, document collection name, and define the appropriate server-side filtering clause.

FederationDataSource - Fluent API for Transformation-Based Queries

The Federation Data Source allows you to flatten (or expand/denormalize) your data source structure via a Transformation option: you can transform inner elements of your data source (such as arrays and lists) into a row set. We will engineer Fluent API for the runtime creation of Transformation-based federated queries.

Your Feedback Matters

As always, please let us know your thoughts in the fields below. We will be more than happy to follow-up should you wish to discuss your needs further.

Free DevExpress Products - Get Your Copy Today