As you may already know, we officially released our JavaScript Gantt control for all supporte JavaScript frameworks including Angular, React, Vue and jQuery.

In this post, we’ll describe some the following new features:

• Gantt Strip lines
• Validation
• Toolbar customization
• Appearance customization.

Strip Lines

Strip lines allow you to highlight specific time points or time periods within the Gantt’s timeline. Use the new stripLines option to add strip lines as needed.

Demo: Strip Lines

Validation

You can now define custom validation rules to check dependencies between individual tasks. When a change in a task or dependency violates dependency validation rules, the Gantt control asks for user confirmation to resolve the conflict – and offers ways to do so.

DevExtreme Gantt can now automatically update parent tasks (start time, end time, duration) each time a user modifies child tasks. Use the new autoUpdateParentTasks option to enable this mode.

Demo: Validation

Toolbar

Our JavaScript Gantt allows you to display predefined (built-in) or custom commands within its Toolbar.

Demo: Toolbar

Documentation: Toolbar

Appearance customization

You can specify custom task colors and resources as necessary. To use this feature, your corresponding data source should contain a 'color' field. If this field’s name differs from the default name ('color') in your data source, specify the colorExpr option to map your data field.

Both the DevExpress Rich Text Editor and Word Processing Document API (v20.1) ship with new table, character formatting and additional content-related capabilities. In this post, we’ll summarize what you can expect in v20.1 and how you can leverage these features in your next app.

Wrap Text Around a Table

Our RTF/Word Processing components (WinForms, WPF, API) allow you to wrap text around a table and specify the table’s position.

We added new API members and User Interface elements to manage/modify table positioning options.

The code sample below demonstrates how you can wrap text around a table:

using (RichEditDocumentServer wordProcessor = new RichEditDocumentServer())
{
  Document document = wordProcessor.Document;
  Table table = document.Tables[0];
  table.BeginUpdate();
  //Wrap text around the table
  table.TextWrappingType = TableTextWrappingType.Around;

  //Specify vertical alignment:
  table.RelativeVerticalPosition = TableRelativeVerticalPosition.Margin;
  table.VerticalAlignment = TableVerticalAlignment.Center;

  //Specify horizontal alignment:
  table.RelativeHorizontalPosition = TableRelativeHorizontalPosition.Margin;
  table.HorizontalAlignment = TableHorizontalAlignment.Center;

  //Set distance between the text and the table:
  table.MarginBottom = Units.InchesToDocumentsF(0.2f);
  table.MarginLeft = Units.InchesToDocumentsF(0.2f);
  table.MarginTop = Units.InchesToDocumentsF(0.1f);
  table.MarginRight = Units.InchesToDocumentsF(0.2f);
  table.EndUpdate();
}

Character Properties Enhancements

This release include new character formatting options. You can now specify spacing, position, kerning threshold and a horizontal scale.

The code example below demonstrates how to specify these options in code:

using (RichEditDocumentServer wordProcessor = new RichEditDocumentServer()) 
{
    Document document = wordProcessor.Document;

    //Change formatting options for the first paragraph:
    DocumentRange range = document.Paragraphs[0].Range;
    CharacterProperties cp = document.BeginUpdateCharacters(range);
    cp.Scale = 150;
    cp.Spacing = -2;
    cp.Position = 2;
    document.EndUpdateCharacters(cp);
}

Our Rich Text Editor/Word Processing components (WinForms and WPF) ship with a new Font dialog tab used to change character spacing parameters.

Custom XML Parts

You can now embed arbitrary XML data (called custom XML parts) within documents (DOCX and DOC formats). You can create, modify or remove custom XML parts, obtain associated content and display it in a document.

The code sample below demonstrates how to retrieve employee names from a custom XML part and display them in the main document.

using (RichEditDocumentServer wordProcessor = new RichEditDocumentServer())
{
    Document document = wordProcessor.Document;
    
    // Load a document.
    document.LoadDocument("Document.docx");
    
    // Access a custom XML file stored in the document.
    XmlDocument xmlDoc = document.CustomXmlParts[0].CustomXmlPartDocument;
    
    // Retrieve employee names from the XML file and display them in the document.
    XmlNodeList nameList = xmlDoc.GetElementsByTagName("Name");
    document.AppendText("Employee list:");
    foreach (XmlNode name in nameList)
    {
        document.AppendText("\r\n \u00B7 " + name.InnerText);
    }
}

Please refer to the following GitHub repository for more code samples: Custom XML Parts Examples

Your Feedback Matters

As always, we welcome your thoughts. Please comment below and let us know what you think of these new features. Once again, should you have technical questions, feel free to contact us via the DevExpress Support Center.

In May 2020, the jQuery team released v3.5.1 to fix a regression and address two security issues.

In this post, I'll discuss why you should update both your jQuery and DevExpress installations.

Security Fixes

The security issues are related to jQuery's DOM manipulation methods (.html(), .append(), etc.):

The second issue was very similar to the first. It was an XSS vulnerability that had to do with passing <option> elements to jQuery’s DOM manipulation methods. Essentially, we’re using a regex to wrap <option> elements with <select> elements to ensure those elements get parsed correctly in old IE (IE <= 9 replaces any <option> tags with their contents when inserted outside of a <select> element). - Timmy Wilson, jQuery Blog

This vulnerability is specific for jQuery versions older than v3.5.0. We encourage you to upgrade to jQuery v3.5.1+.

Upgrade DevExpress

While many DevExpress web components use jQuery, this vulnerability does not affect our web controls directly. However, if you're using the vulnerable jQuery methods mentioned above (for user input), compromising code can be injected from the client browser.

The good news: this vulnerability has been fixed in jQuery v3.5.1+. As such, we've updated the following versions of our product suite:

• v19.1.11
• v19.2.8
• v20.1.4

I recommend that you install our update - this will be the easiest way to move to jQuery v3.5.1.

Learn more here: DevExpress Security Advisory

Upgrade npm packages

Please run the following command - it'll update your jQuery to the latest version:

npm i jquery

If you encounter any issues, please contact our support team for immediate assistance.

Our v20.1 release includes an extended list of the control appearance properties. This blog post summarizes appearance customization enhancements you can integrate in your DevExpress-powered WPF app today.

DateNavigator Control

You can now specify cell appearance for the following cell states:

• MouseOverState
• DisabledState
• InactiveState
• FocusedState
• SelectedState
• TodayState
• SpecialDateState
• HolidayState
• NormalState.

The code sample below specifies aspecial date foreground and disables highlighting for the current date:

<dxe:DateNavigator>
	<dxe:DateNavigator.Appearance>
		<dxe:DateNavigatorCellAppearance>
			<dxe:DateNavigatorCellAppearance.SpecialDateState>
				<dxe:DateNavigatorStateAppearance Foreground="#FF7200" BorderThickness="0"/>
			</dxe:DateNavigatorCellAppearance.SpecialDateState>
			<dxe:DateNavigatorCellAppearance.TodayState>
				<dxe:DateNavigatorStateAppearance BorderBrush="White"/>
			</dxe:DateNavigatorCellAppearance.TodayState>
		</dxe:DateNavigatorCellAppearance>
	</dxe:DateNavigator.Appearance>
</dxe:DateNavigator>

Standard Properties Support

We extend the list of controls that support the following standard customization properties:

• Background / Foreground
• BorderBrush
• BorderThickness
• CornerRadius
• Margin / Padding

Our most recent themes (Office 2016 SE, Office 2019, VS 2017, VS 2019) now offer enhanced templates for the following controls:

• Ribbon items, pages, categories, and groups
• Toolbars and Toolbar items
• Context menu and Context menu items
• SimpleButton, DropDownButton, and SplitButton

Supported appearance settings allow you to quickly customize look and feel throughout your application or create individual UI elements that stand out from the rest. For example, the code snippet below creates an orange action button that your users won’t miss.

<dx:SimpleButton Content="Simple button" Background="#FF7200" Foreground="White" 
Padding="10" CornerRadius="5" BorderBrush="#505050" BorderThickness="3" …/>

Bar Triggers

As you may know, Toolbar items used in DevExpress Ribbon and Toolbars are non-visual elements that generate visual counterparts in the UI. The same item can be displayed in multiple places at the same time. For example, the image below displays the same items on a Ribbon page and in the Quick Access Toolbar area:

Because Toolbar items are non-visual elements, it is hard to customize associated visual states with regular WPF triggers. In v20.1, we introduced custom triggers for Toolbar items. These triggers provide the same functionality as regular WPF triggers, but can be defined for Toolbar items directly.

Here's how to customize the appearance of BarCheckItems based on checked state:

<dxb:BarCheckItem Content="Private" …>
	<dxb:BarCheckItem.Triggers>
		<dxb:ItemTrigger Property="IsChecked" Value="True">
			<dxb:ItemSetter Property="Background" Value="#ffeb3b"/>
		</dxb:ItemTrigger>
	</dxb:BarCheckItem.Triggers>
</dxb:BarCheckItem>
<dxb:BarCheckItem Content="High Importance" …>
	<dxb:BarCheckItem.Triggers>
		<dxb:ItemTrigger Property="IsChecked" Value="True">
			<dxb:ItemSetter Property="Background" Value="#d20f38"/>
			<dxb:ItemSetter Property="Foreground" Value="White"/>
		</dxb:ItemTrigger>
	</dxb:BarCheckItem.Triggers>
</dxb:BarCheckItem>

Feedback

As always, we welcome your thoughts/opinions. Please post a comment below and let us know what you think about our new WPF Appearance Customization options.

Needless to say this has been quite a challenging year for everyone. I certainly hope you and your loved ones are in good health and that your business is on its road to recovery.

Since we've reached the mid-way point of 2020, I thought it would be good time to describe what we've accomplished so far this year and what we expect to release by year's end.

v20.1

Here's a brief summary of a few DevExpress Dashboard-related features we released last month (You can find additional information within our What's New v20.1 webpage).

Ongoing Enhancements

Thanks to some insightful feedback in our "Are we on the Same Page – 2019" survey, we were able to extend the capabilities of our Dashboard API in the first release of 2020. Specifically, we:

• Added APIs to enhance the capabilities of WinForms State Management.
• Added parameters support for JSON Data Source.
• Recreated documentation for Data Inspector (we noted that many readers missed Web Data Inspector's ability to export data to Excel).

I want to extend my thanks to everyone who contributed to the evolution of DevExpress Dashboard. Your feedback and engagement matters. We are definitely listening and doing everything we can to meet your expectations.

Lifecycle API

We delivered about 50 new APIs (methods, events, extended event arguments, enumerations) in 12 groups. Together, they offer new opportunities for those using DevExpress Dashboard. Simply said, our new API allows you to embed new end-user options and commands for DevExpress Dashboard's Designer controls.

We also reworked our documentation and created a single-entry point that lists all current customization options:

• Web Dashboard Customization Options,
• WinForms Designer Customization,
• WinForms Viewer Customization
• WPF Viewer Customization.

Еach help topic refers to the samples that demonstrate capabilities. You can download and modify these samples as needed.

The Dashboard's Lifecycle API was first released as an EAP. Once again, your feedback helped us shape its direction. Thank you.

Week-Year Group Interval

Yes, here's another feature that was driven by customer feedback.

We discovered that our default approach to divide time into Weeks based on current Culture Settings, sounded logical but did not effectively address user requirements. Basically, we learned that users do not expect that a week at the beginning of the year can be divided into two parts.

So this lesson forced us into a breaking change (v20.1.4). Our new group interval will always break a timeline into equal periods. Of course, we sincerely apologize for the breaking change and the fact that unexpected behavior made its way into production code. Thanks to everyone who helped us fix this error.

Card Conditional Formatting

This was a highly demanded feature. Once incorporated into your Dashboard, you'll have more opportunities to focus user attention on unexpectedly bad (or good, or just… unexpectedly unexpected) KPIs.

You can use Formatting Styles – styles that mirror those of the DevExpress Data Grid/Pivot Grid - as needed. You can change selected Card element Font, add an Icon or apply a background color to the entire Card.

Parallel Periods

When investigating this feature, we dropped our intent to introduce a new Window Calculation. We made this choice because we found that it was both overcomplicated inflexible. Instead, we added two new methods to visualize and compare your data:

1. With Measure Filter, you can compare data between predefined DateTime periods.
2. If using calculated fields, you can use the joinRule function (extends Aggr syntax) to shift the Measure value by the DateTime axis.

You can review both methods in our YTD Performance demo.

Are we on the same page?

Before we move to v20.2, we'd like to gauge the overall effectiveness of our v20.1 development efforts. Please take a moment and tell us which of the following v20.1 features you've used or plan to use in an upcoming project.

Ok – time to focus on our upcoming release.

What we expect to ship in v20.2

Additional API enhancements

"Great things are done by a series of small things brought together." (Vincent Van Gogh)

Just last week I came across this quote and thought that it describes our new API set quite well.

We have already adopted this approach in the Lifecycle API. 50 members, used together, create a complete picture.

Real-Time Dashboards

Just like with our Lifecycle API, we want to introduce a series of enhancements and customization options. Together they will allow you to better monitor real-time values using DevExpress Dashboard.

We are considering the following enhancements:

• Reworked and configurable loading indicators.
• Improved data update mechanisms.
• Cache management API for real-time scenarios.

Web Dashboard – Wrappers for Modern Web Frameworks

We want to better support those who develop modern web apps using popular client frameworks.

We plan to introduce platform-specific wrappers for our Web Control. These wrappers will simplify how you add our Dashboard control to your application and bind it's options to your View Models. We'll make it easier to configure the Dashboard control and connect it to your .NET backend (MVC or ASP.NET Core).

Filtering Enhancements

We believe that the DevExpress Dashboard Master-Filtering system is one of the simplest and one of the most powerful data filtering systems available today. Of course, we still want to extend its capabilities and make it even more flexible. While working on the Measure Filter last year, we came across ways to retain simplicity and increase flexibility at the same time.

We expect to introduce the following filtering options this year.

• Allow the use of Master-Filter values as a part of Filter expression for Dashboard Item Filter / Measure Filter;
• Introduce a new Post-Calculation step or a "Final Filter." This can be applied to data when all calculations, grouping and aggregation are finalized.

We are prototyping so we can't be certain that this will be delivered in exactly this shape. We'll share some of our results with you soon.

Trends & Regression Lines for Chart Item

We are investigating the best way to use Trends Lines and / or Regression Lines within applications powered by DevExpress Dashboard.

We've concluded that in addition to visual elements, customer requirements vary greatly (variances in the type and parameters and trends calculation logic). This led us to the following feature – post-processing…

Custom Calculation Step

We are considering a new API that allows you to post-process data prepared by our Data Processing Engine (to add additional columns with data calculated on your side). This should give you maximum flexibility during data preparation.

Better Async Support in WinForms Dashboard Designer

Based on feedback, we expect to improve Async support for WinForms / WPF Dashboards. This work has already begun.

Data Source – Unfolding Nested Arrays

Like most analytical tools, DevExpress Dashboard works natively with so called flat Fact Tables.

This is great but does not help if your JSON/Object/XPO formatted objects have nested arrays and require you to unfold as a preprocessing step.

In v20.2, we expect to introduce a new option designed to transform data on our end (part of our ETL engine).

Chart Conditional Formatting

With conditional formatting, Dashboard Charts will be able to highlight values that correspond to specific criteria.

Before we let you go

Your feedback matters a great deal. Please help us further improve DevExpress Dashboard by answering the following survey questions:

We updated our Blazor demo and have created an intermediate build to demonstrate recent Blazor UI enhancements. 

• Online Demo
• DevExpress .NET Components Installer v20.1.4.20171
• Blazor Demo source code

New Features

Validation

XAF's Validation Module now displays error messages within the UI as follows: 

• When an invalid value is entered and focus leaves the editor, XAF highlights the editor. In desktop browsers, a validation message is displayed within a tooltip. In mobile browsers, the validation message is displayed below the editor. 
• If changes cannot be saved due to validation errors, details are displayed within a validation panel. 

Adaptive Toolbar

• Menu captions are automatically hidden and displayed based on page width. 
• Menu items that do not fit within a page are placed onto an overflow menu.

We applied this change recently, and the feature has known issues. Please see below.

Model Editor

• The DevExpress .NET Framework Unified installer now includes a Model Editor for .NET Standard projects. Previously, this was available only with the .NET Core Components installer (learn more).
• Model Editor uses the current Visual Studio skin.

Please review the following article to test our Blazor UI (CTP) with existing projects: How to port an XAF platform-agnostic module to .NET Standard 2.0+.

Known Issues

This intermediate build has the following issues:

• Clicked menu buttons remain in a pressed state;
• An empty overflow menu is displayed after navigating to Contacts. 

Review other known issues and future plans in the following article: FAQ: XAF ASP.NET Core Blazor Server UI (CTP).

Old Mobile UI Deprecation in v20.2 

Things are going according to plan and we are moving towards our Blazor UI release in v20.2: eXpressApp Framework - 2020 Roadmap. 

In v20.2, we will also remove XAF's hybrid mobile-related tools for PhoneGap from our core installation. These mobile-related tools were in maintenance mode from 2018. Existing mobile applications will continue to work with previous versions of XAF.

Your Feedback Matters

As always, we welcome your thoughts. Please comment below and let us know what you think of these new features. Once again, should you have technical questions, feel free to contact us via the DevExpress Support Center.

All Platforms

• PivotGrid - How to show dates in datetime format within rows\columns (T893092)
• List - How to prevent swiping of a specific item (T884910)
• DataGrid - How to scroll a grid's data based on a different grid's scroll state (T881641)
• TagBox - How to prevent custom item generation when input is invalid and while using fieldTemplate (T894323)
• DataGrid - How to hide a group row if this group contains a single data row (T668464)
• DataGrid - How to convert the current filter to an XPO criteria string (T892060)

Angular

• DataGrid - How to implement a custom compare function for search (T893451)
• DataGrid - How to display an edit form in readOnly mode on a custom button click (T883821)
• DataGrid - How to implement a custom export button (T875219)
• List - How to prevent template re-rendering when a new item is added (T887456)
• DataGrid - How to close a lookup cell after a value is selected (T890095)

React

• DataGrid - How to hide empty rows and columns when exporting to Excel (T893072)
• List - How to implement drag and drop functionality via React Hooks (T881943)
• Reactive Grid - How to change the default filter operation (T893386)

Vue

• DataGrid - How to set default values for new rows (T893494)
• DataGrid - How to highlight DataGrid on drag and drop (T892638)
• How to change themes at runtime (T897280)

Feedback

Here is this month’s edition of our WPF Tips & Tricks blog post. Hopefully you’ll find the following technical support tickets of value in your current WPF project.

We also created a new example that demonstrates how to create a real-time chart and compiled a KB article describing the multi-select capabilities of our WPF Data Editors.

Should you have any questions, feel free to comment below.

KB ARTICLE:

• How to implement multi-select when using DevExpress WPF Data Editors (ComboBoxEdit, LookUpEdit, ListBoxEdit) (T889444)
  

  Our ComboBoxEdit, LookUpEdit, and ListBoxEdit allow end-users to select multiple items. In this KB article, we describe how to enable multiple selection and how to bind these editors to data and use them within WPF Data Grid cells.
  

EXAMPLE:

• How to: Create a Real-Time Chart (T894632)

TICKETS:

WPF Data Grid

• How to change the fill color in DataBarFormatConditions based upon a specific cell value (T898500)
• How to format tooltip values defined via CellToolTipBinding (T897646)
  

  The Binding mechanism uses the FormatString property value only if the target property is a String. To format cell tooltips defined via CellToolTipBinding, you can implement a custom converter or use our DXBinding feature:
  

  <dxg:GridColumn FieldName="Date"
                  CellToolTipBinding="{DXBinding Expr='Date.ToString(`ddd, d MMM yyyy`)'}">
      ...
  </dxg:GridColumn>
          

• How to center cell content in WPF Data Grid columns (T893136)
• How to merge a specific cell range with the same value in a WPF Data Grid column (T893139)
• How to hide WPF Data Grid control bands during print operations (T890413)

WPF Editors

• How to display TreeListView in LookUpEdit's popup and select child and parent nodes (T892988)
• How to implement a custom DateEdit and correct values automatically (T888590)
• How to keep a popup closed during text input in LookUpEdit (T892998)
• How to enable smart column generation in the LookUpEdit’s GridControl (T890940)
  

  LookUpEdit does not enable smart column generation in its GridControl. To enable this feature, you can override the Embedded GridControl or set the EnableSmartColumnsGeneration property to True at the implicit style level:
  

  <Window.Resources>
      <Style TargetType="dxg:GridControl">
          <Setter Property="EnableSmartColumnsGeneration" Value="True"/>
      </Style>
  </Window.Resources>
          

WPF Docking

• How to display a hidden LayoutPanel when the mouse cursor hovers over the AutoHideGroup tray (T890480)

WPF Charting and Maps

• Legend - How to maintain Series checkbox state when new data is added in Series Template data binding mode (T893864)
• How to ensure that the topmost Y-Axis label is displayed (T895008)
• How to bind vector items to a view model in Map Editor mode (T895626)
• How to set MapControl’s background color when a map is exported to an image (T889416)

WPF Ribbon & Bars

• How to define BarButtonItem's tooltip duration when a DX theme with lightweight templates is used (T895793)
• How to stretch items in RibbonStatusBarControl (T893029)

WPF Scheduler

• How to customize Appointment and Recurrence windows (T890072)

Other Controls

• How to enable the MouseWheel event in the Adorner Control when DX themes are used (T895687)
  

  We patch ScrollViewer's default scrolling logic in our themes. With this, we implemented horizontal scrolling via the mouse, supported touch mouses, etc. To keep using default scrolling logic, set the ScrollBarExtensions.HandlesDefaultMouseScrolling attached property to False:
  

  
  xmlns:dx="http://schemas.devexpress.com/winfx/2008/xaml/core"
  <UserControl.Resources>
      <Style TargetType="ScrollViewer">
          <Setter Property="dx:ScrollBarExtensions.HandlesDefaultMouseScrolling"
                  Value="False"/>
      </Style>
  </UserControl.Resources>
      

If you’ve come across a WPF-related support ticket you’d like to share with the rest of the DevExpress community, feel free to share the link in the comments section.

Time flies – we are already halfway through 2020. We certainly hope that you and your loved ones are doing well and staying safe.

Here is this month’s edition of XAF Tips & Tricks. Please let us know if you find the information below of value and tell us how we can improve this content going forward. 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 - Refresh a Detail View after saving changes in its nested List View (T900526)
• Core - When and why you need to unsubscribe from events (T893208)
• Core - We published the new NuGet package DevExpress.ExpressApp.DBUpdater (T885016)
• Blazor - Deploy an application on Ubuntu
• Security - When the Conditional Appearance Module is better than Action Permissions (T894159)
• Security - We added new validation and appearance rules for PermissionPolicyUser and PermissionPolicyRole. They help you to avoid unnecessary permission editing for administrative roles and prevent deletion of the last active Administrator or the last administrative role (T898638)
• XPO - Recommendations on asynchronous data loading (T894599)
• WinForms - Integrate a map into your XAF WinForms application (T287322)
• WinForms - Invoke the Model Editor in code and customize its default settings (for instance, focus a node) (T895223)
• WinForms - Show business objects on a Kanban Board (T886578)
• Web - Initialize a new object created in a nested List View in Batch edit mode depending on master object properties (T896906)
• Web - Indicate that a Detail View contains changes in the UI (T898453)
• Web - Download a file when clicking the OK button in a popup window
• Web - Customize a Detail View opened when clicking the New button in a lookup editor (T897024)

Resolved Issues

• Core - The SupportsAsyncLoading rule causes recurrent "IModelViewWin expected" exceptions in the Model Editor (T894836)
• XPO raises "Object reference not set" when OData is used in some circumstances (T903105)

New and Updated KB Articles

• Core - How to port an XAF platform-agnostic module from .NET Framework to .NET Standard 2.0+
• Core - FAQ: Model Editor for .NET Core and .NET Standard (CTP)
• Blazor - FAQ: XAF ASP.NET Core Blazor Server UI (CTP)
• Security - FAQ: XAF User Authentication and Group Authorization API for DevExpress XPO and Microsoft Entity Framework Core ORMs
• XPO - FAQ: Async/Await Method Support
• Troubleshooting - How to resolve the "Cannot modify Dictionary because ThreadSafeDataLayer uses it" error
• Troubleshooting - How to resolve the "Reentrancy or cross-thread operation detected" error

Documentation Updates

XPO Query Parameter Validation

We softened default parameter validation in SELECT, UPDATE, and INSERT statements and introduced a new DevExpress.Xpo.DB.QueryParameterMode enumeration. You can set the ConnectionProviderSql.QueryParameterMode field or the ConnectionProviderSql.GlobalQueryParameterMode static field as needed.

using DevExpress.Xpo.DB;  
//...  
ConnectionProviderSql.GlobalQueryParameterMode = QueryParameterMode.Legacy; 

Unit and Functional Testing

We reworked and updated the Functional Tests (EasyTest) help section and added a new help topic to improve navigation between learning materials related to unit and functional testing.

FirstOrDefault Methods

The IObjectSpace interface includes the following new methods:

• FirstOrDefault<ObjectType>(Expression<Func<ObjectType, Boolean>>)
• FirstOrDefault<ObjectType>(Expression<Func<ObjectType, Boolean>>, Boolean)

These methods mirror our FindObject<ObjectType>(CriteriaOperator) and FindObject<ObjectType>(CriteriaOperator, Boolean) methods, but accept a lambda expression as the first parameter.

// v20.1.4:
ObjectSpace.FirstOrDefault<Person>(p => p.FirstName == "Test");
// Older versions:
ObjectSpace.FindObject<Person>(CriteriaOperator.Parse("FirstName=?", "Test"));
ObjectSpace.FindObject<Person>(new BinaryOperator(nameof(Person.FirstName), "Test"));
ObjectSpace.FindObject<Person>(new OperandProperty(nameof(Person.FirstName)) == "Test");
ObjectSpace.GetObjectsQuery<Person>().Where(p => p.FirstName == "Test").FirstOrDefault();

LINQ may be more convenient than CriteriaOperator and more natural for Entity Framework users. XPO users may also like this shortcut.

Non-Persistent Objects

• How to implement CRUD operations for Non-Persistent Objects stored remotely
  
• How to edit a collection of Persistent Objects linked to a Non-Persistent Object

Non-Persistent Object Enhancements

Our upcoming v20.1.5 release will offer the following enhancements to non-persistent objects.

• NonPersistentObjectSpace will include a FindObject(Type, CriteriaOperator, Boolean) method overload. This method iterates objects loaded with GetObjects, GetObject, CreateObject (etc) methods, and returns the first object that matches the specified parameters.
• NonPersistentObjectSpace supports custom fields (both calculated and non-calculated). You can create these in code and via the Model Editor (just as you would for persistent objects).
• You can inherit the new NonPersistentObjectBase class instead of creating a Non-Persistent Object item from the Template Gallery.
  

A splash screen is an effective way to improve an app’s user experience during lengthy startup operations. Unfortunately, creating an effective splash screen can be tricky because two competing objectives must be addressed simultaneously:

• A splash screen needs to be visually appealing. It’s your first chance to make a great impression.
• A splash screen should load instantaneously. Loading delays will defeat the overall purpose of the splash screen.

As you may already know, our WPF Subscription includes DXSplashScreen - A UI component that was built years ago to help you create and add splash screens to any WPF app.

Our latest release (v20.1) includes an entirely new Splash Screen control - a UI component we’ve named SplashScreenManager.

Let’s quickly look at the new DevExpress Splash Screen Manager, review why it was built, and why we replaced DXSplashScreen.

Design Elegance

Our Splash Screen Manager ships with two predefined styles – Themed, Fluent (Acrylic).

As its name implies, a Themed Splash Screen uses the same color scheme as that used by your application.

Our next predefined style - Fluent Splash Screen - features an Acrylic effect. As you can see below, this splash screen uses a translucent background. Once again, we’ve optimized the splash screen as much as possible – making certain that it loads quickly.

App-wide Wait Indicators

Wait Indicators are a great way to provide feedback during time-intensive operations. I can cite countless examples to illustrate this point. For instance, a wait indicator will improve an app’s user experience during long fetch operations.

You can use our new Splash Screen Manager to create wait indicators within your app as needed. Simply set the owner and trackOwnerPosition parameters of the Show method to place a splash screen atop a specific UI element and keep it there if the user resizes or drags the window around.

Splash screens created with the Splash Screen Manager are processed in a separate thread and do not interfere with the main application flow.

However, you may want to control user interaction with your application once you’ve displayed the “splash screen” in this specific usage scenario. This can be done with a single method parameter. Your options vary: you can block the application, restrict input within the window but allow the user to drag the window around, or block a specific element. It’s all up to you.

Performance

This post began with a simple proposition – a splash screen must be loaded quickly. Well, we designed SplashScreenManager so it’s fast. To maximize performance and ensure a timely display, we’ve made certain not to load all DevExpress Theme resources – We load what we need so we can render the splash screen quickly.

We have measured the startup time on different PC configurations with and without the Ngen.exe optimization:

Themed Splash Screen: 290-450 ms

Fluent Splash Screen: 300-460 ms

Compiled with Ngen.exe:

Themed Splash Screen: 170-370 ms

Fluent Splash Screen: 180-370 ms

In comparison, DXSplashScreen (with a default template) renders in 720-1000 ms. (450-900 ms after Ngen.exe compilation). The bottom line is this: our new SplashScreenManager loads about 50% faster.

Of course, performance metrics are app dependent. If you’d like to take a closer look at our comparison figures, simply download this project from Github: https://github.com/DevExpress-Examples/splashscreenmanager-startup-test

Ease of Use

We’ve tried to make use of the SplashScreenManager as painless as possible. Here is how you can integrate it into your next app:

Step One - Add the following code to App.xaml.cs:

SplashScreenManager.CreateThemed(new DXSplashScreenViewModel { 
    Status = "Starting...", 
    Title = "The Best or Nothing!" } 
).ShowOnStartup(); 

Step Two – Just kidding, there’s no second step. The code above generates a splash screen using an application’s default color scheme, displays it with a priority over the main application to minimize delays, and hides it once the application is initialized.

Ease of Customization

You can edit the content of our predefined splash screens with a few lines of code by accessing the view model. You can swap the image used, edit displayed text, and modify progress bar value.

If you require more extensive customization, you can incorporate a predefined splash screen from our Template Gallery or implement your own design from scratch. Our documentation includes a tutorial to help simplify this process.

MVVM in Mind

We extended our set of services to help you add SplashScreenManager functionality to MVVM-compliant applications. Add a splash screen from our template gallery to your application, customize it as you see fit and then add the SplashScreenManagerService to your view of choice. Easy as 1-2-3.

Feedback

If you’d like to share your thoughts about SplashScreenManager, please post a comment below. We’ll be happy to follow up.

We’ve put together a list of interesting support tickets answered throughout May and June. We hope you find these support tickets interesting and of business value. Should you have any questions, feel free to comment below.

Tips & Tricks

• Word Processing:How to determine whether a paragraph is located inside a table (T889828)
• Word Processing:How to link a DOCVARIABLE and an INCLUDEPICTURE fields in code (T892334)
• Word Processing:How to search text in a document range (T896511)
• Spreadsheet Document API:How to export a worksheet to a tab-delimited text file (T887412)
• Spreadsheet Document API:How to clear a cell’s background color (T885686)
• Spreadsheet Document API:How to specify a multi-line chart title (T897654)
• Spreadsheet Document API:How to combine data from multiple worksheets into a single worksheet (T888051)
• Spreadsheet Document API:How to set the default number format for the entire workbook (T890284)
• PDF Document API:How to retrieve a page where the form field's widget is located (T890570)
• WinForms Rich Text Editor:How to paste images from the Clipboard as metafiles (T867921)
• WinForms PDF Viewer:How to handle a click on a button form field (T891909)
• WPF PDF Viewer:How to display a custom title for the Print dialog (T901762)
• WPF PDF Viewer:How to add a custom panel to the Dock Layout Manager (T899605)
• WinForms Spreadsheet:How to use worksheet data as a data source for the Chart Control (T892734)
• WinForms Spreadsheet:How to implement the "Insert Copied Cells" option like Microsoft Excel (T899515)
• WinForms Spreadsheet:How to copy a chart from one worksheet to another (T898461)

Enhancements

• Word Processing:RichEditDocumentServer now preserves "Fill in Forms" protection mode when a document is saved (T898685)
• Word Processing:We implemented support for “AppVersion”, “Application”, “Company”, “Manager” and “Template” document properties. (T905990)
• Word Processing:You can now specify Alt Text for a shape (T891124)
• Word Processing:You can now set the "Lock anchor" option for shapes in code (T877253)
• PDF Document API:You can now extract text from a page without clipping (T903241)

If you’ve come across an interesting support ticket you’d like to share with the rest of the DevExpress developer community, please comment below and include the appropriate link.

In January 2020, we published our Blazor UI - 2020 Roadmap for the first half of 2020. Based on survey results and Support Center feedback, we’ve finalized our 2020.2 Roadmap. We want to thank you for your continued support and for your insightful comments.

New Components

Memo control

We're creating a new editor component that allows you to display and edit multi-line text. Our Blazor Memo component will ship with both data binding and validation support.

Drop Down Button

Our new Drop Down Button will allow your end-users to select from a list of items.

Drop Down Edit

The Drop Down Edit component will be able to display custom content within its list.

Page Layout

Our Blazor Page Layout component will help you create custom page layouts with ease.

Menu

The DevExpress Blazor Menu component will include support for hierarchical items, items group, left and right item alignment, and templates.

Navigation Bar

Our new Blazor Navigation Bar component will include built-in templates so you can create custom navigation items as needed.

Data Grid

Total Summaries

We're adding a set of predefined total summaries (Min, Max, Sum, Average, etc.) These aggregate function values are calculated against all rows in the Grid and displayed within the Blazor Grid’s footer.

We're also adding custom summary support so you can calculate summaries against records that meet specific criteria. You will also be able to use multiple data fields in your calculations.

Group Summaries

We expect to add a set of predefined summaries and a custom summary for the Blazor Grid’s group row or its group footer.

Column Customization

A new property will allow you to improve column appearance by assigning custom CSS classes to column markup.

Popup Edit

A new edit mode will allow your end users to edit cell values inside a popup edit form.

Inline Edit

Our Blazor Grid’s Inline Edit mode will allow your end user to edit cell values within the current edit row.

Filter Enhancements

We'll introduce the following new filter options to our Blazor Grid:

• Popup Header Filter
• Search Panel
• Advanced Filter API

Frozen Columns

Our Grid will ship with support for Frozen columns. This will allow end-users to lock columns in one area and keep this area visible during horizontal scroll operations.

Column Resize

With our new column resize feature, your end-users can easily modify column width via the mouse.

Automatic Data Updates (Observable)

Our Blazor Grid will allow you to bind to ObservableCollection and implement the INotifyPropertyChanged interface. The Grid will automatically update when changes are made to the observable collection.

Scheduler

Custom Fields

Our Blazor Scheduler control will support custom (data bound) fields so you can display and save custom information within an appointment form.

Custom Appointment Form

The Scheduler will allow you to customize the layout of the appointment edit form.

Filter and Group by Resources

The Scheduler will include an option to filter and group appointments by resources (for example employees, hotel rooms, etc.).

Timeline View

The Scheduler will ship with a new Timeline View. The timeline will display appointments/events as horizontal bars along its timescale. This new UI paradigm will give end-users a clearer picture of upcoming/past events.

Data Editors Enhancement

Multiple Columns

The ComboBox, List Box, and TagBox components will include support for multiple columns (display list data across multiple columns).

Two-Way Binding

With two-way binding, you will have the option to bind a value from the ComboBox and TagBox with either a stand-alone variable or your Model's property.

Masked Input

Our Blazor Text Box, ComboBox and data editors that include a text field will support custom Masks (to help you manage user input).

Focus an Editor in Code

We're enhancing our editor's API so you can set focus on the data editor within code.

Item Template

Our List Box and ComboBox will include a new template region. You will be able to display custom information within this region as needed (will include support for an image within the input box).

Time Section in Data Edit

The Date Edit component will incorporate a time edit section and allow end-users to set time values alongside dates.

ComboBox Drop Down Width

We're adding an option to control the width of the ComboBox's drop down. The drop down's width will be calculated from either the:

• drop down content width
• entire width of the editor

Alternatively, you can use the expandable option. This option will allow width to increase or decrease as necessary.

Adaptivity Enhancements

For mobile devices, we're adding a popup and modal mode for the drop down window. These modes mimic the behavior of a standard drop down control on mobile browsers.

Visual Studio Integration

To help you get started with our Blazor UI components, we're creating new Project templates for both Blazor Server and Blazor WebAssembly applications.

Before we let you go

Your feedback matters a great deal. Please help us further improve DevExpress UI Components for Blazor by answering the following survey questions:

We know that many of you leverage the capabilities of DevExpress Reports to generate invoices, receipts and payment slips. Those that require QR-bill support, will be happy to know that DevExpress Reports now includes QR-bill support via a new report control.

For more information on QR-bill and Switzerland’s new payment standard, please follow this link: QR-bill.

Swiss QR-bill Control - Key Features

• .NET QR-bill control manages inner margins automatically based upon displayed data.

• The control is bound to a string field, and you can extend it with other fields when necessary.

• PDF and print preview settings include options for tear lines so you can decide how to arrange lines.

• Ability to print on A4 and A6 landscape paper.

• Arrange bills individually (i.e. on one order - one receipt; or arrange multiple bills on the same page).

• Support for languages specified in the QR-Bill standard.

• Smart Tag actions available at design time.

We’ve created a complete sample project for WinForms and our Visual Studio Report Designer. To download, simply point your browser to the following GitHub repository: DevExpress Reports - Custom Controls. You will also find a detailed technical description in the readme file within the repository.

Your Feedback Matters

As always, we welcome your thoughts. Please explore the capabilities of the QR-bill control and share your experiences with us.

We will soon host a TestCafe webinar that will cater to both first-time users and those who may have tried TestCafe (our end-to-end web testing tool) in the past. Paul Usher, our technical evangelist and live session host, will begin with first-time setup and then will go into a few of the more recent TestCafe innovations. He will also cover the differences between TestCafe Open Source and TestCafe Studio. See the details below.

Upcoming Webinar: 10 Ways to Simplify UI Testing

See how you can easily incorporate UI testing in your development workflow. In this presentation, Paul Usher will show you how TestCafe can be leveraged to deliver high quality web apps that always meet end-user expectations. You’ll discover:

• How to setup TestCafe and start testing in under 10 minutes.
• How to create customizable tests that can easily evolve as business requirements change.
• The purpose of Custom Selectors and why they make web testing so much easier.
• The purpose of the Page Model approach and why it helps increase productivity.
• And you’ll learn how to master use of Smart Assertions.

Register Now
Date and Time: July 29th at 10am Pacific Time.

What's So Cool about TestCafe?

TestCafe Open Source and TestCafe Studio are driver free and do not require you to manage complex plug-ins. Their flexibility and ease of use are probably best illustrated by the ability to run tests on remote browsers across multiple devices and platforms. TestCafe Studio generates a URL used to connect to the test runner... or a QR code so you can easily connect your mobile devices.

This functionality is not limited to TestCafe Studio. You can do the same if you use our open source TestCafe library and start your tests from the command line:

The URL provides access to run the tests the remote device. This minimal setup philosophy always has been our guiding principle in all areas of web testing - from installation to test debugging.

Something #webdriver can’t do... #testcafepic.twitter.com/bgD8cgUwXX

— TestCafe (@DXTestCafe) December 1, 2016

If you'd like to know more - register for the webinar on July 29th. Even if you cannot attend the live session, we'll make sure to send out a recording to all registrants.

We are working hard to make our next WinForms release (v20.2) the best ever. We have a lot of information to share about v20.2 and I will blog about release plans in August. For this post, I wanted to share a few ideas/UI suggestions and demonstrate how our WinForms products have evolved in recent release cycles.

Side Navigation

In times past, apps that required “side navigation” functionality often relied on the DevExpress WinForms NavBarControl was your way-to-go pick for many years. to do the heavy-lifting. Our NavBar control shipped with everything one would expect from a navigation bar. It allowed you to create empty items or populate them with custom content. It allowed you to add items that mimicked buttons or incorporate selectable items that retained user focus. The NavBar allowed you to categorize elements into groups, choose one of three behavior modes, auto-populate the Office Navigation Bar with NavBarControl groups, etc. Yes, the NavBar control was (and is) awesome. The good news is that all major NavBar related functionality is now available in its heir apparent – the DevExpress WinForms Accordion Control.

In addition to all the things mentioned above, our Accordion UI component also offers:

• custom header buttons inside items and groups;
• an embedded Find Panel to help users locate information in an intuitive manner;
• web-inspired Hamburger style menu;
• improved high-DPI support, and much more.

If the Accordion’s built-in advantages have yet to convince you of its utility, consider the following. When you place an Accordion Control inside a Fluent Design Form, it can do what no other navigation control can: stretch vertically across the entire form, overlapping its title bar. It will also automatically expand or collapse based on current form width. Thanks to its semi-transparent Acrylic Material support (powered by DevExpress DirectX Hardware Acceleration), it does all this in a highly elegant manner.

Alerts & Notifications

Traditional Alert Windows managed by our WinForms AlertControl are simple message boxes with custom styling. They appear and disappear without a trace when a user closes the alert. Though Alert Windows can service certain needs, we think a better alternative exists... Toast Notifications.

Toast Notifications were first introduced in Microsoft Windows 8 and are much more powerful than traditional “alert windows”. Toast notifications are stored in the Windows Notification Center and allow users to read unread messages in a centralized location. Native Toast Notifications can use system colors and sound settings. These notifications can also display UI elements (to help your app interact with the user) and support the all-important "Snooze" command (delay the notification for a later time).

The DevExpress Toast Notification Manager component uses Microsoft’s Windows API and allows you to create native Toast Notifications with absolute ease. A few months ago we published a comprehensive tutorial for this component. If notifications play an important role in your app, please review the following blog post to learn more: How to Display Toast Notifications in WinForms Apps.

Unbound Data

All of our market-leading data-aware controls (WinForms Data Grid, Tree List, Vertical Grid, etc.) fully support unbound data operations. In unbound mode, records are not retrieved from a data source – they are passed to the UI control manually.

So how can you pass unbound data to a data-aware control? It’s simple – for example, to populate our WinForms Data Grid with unbound data, you need to create unbound columns and handle the CustomUnboundColumnData event.

Though you can still use Unbound column events, our DevExpress WinForms Controls suite now ships with a special data source component designed to facilitate unbound data management. This control – the UnboundSource component - fires two events: ValueNeeded (when a data-aware control requires new data) and ValuePushed (when control data has changed and requires you to save modifications). Unbound Source repeatedly fires the ValueNeeded event until record number reaches the number assigned via the SetRowCount method. This straightforward approach allows you to easily scale the data passed to your data-aware control and instantly clear it (by passing zero as the method value). If you’re ready to explore the capabilities of UnboundsSource, feel free to review the following help topic for more information: Unbound Sources.

In addition to UnboundSource, the DevExpress WinForms suite includes an event-based VirtualServerModeSource component. This component allows you to load large data sets in small portions. When used, data-aware controls leverage our Infinite Scrolling mode (an alternative to traditional record paging).

Flyouts

While the word "flyout" may be a relatively new term in the DevExpress WinForms vocabulary, the idea of small panels that pop up in the corner of the screen is nothing new. Years ago you had to use custom floating forms to display such panels. With our WinForms Flyout Panel, you can now incorporate this capability quite easily. Simply drop the Flyout Panel onto your form, choose its position and animation effects, populate it with content and call the ShowPopup / HidePopup methods to toggle panel visibility. The animation below illustrates how we use the Flyout Panel within the DevExpress PDF Viewer (to display a Find panel).

Flyout Panels support an alternate "Beak Panel" style. “Break Panel” allows you to display interactive hints for any UI element on your form. To open a Flyout Panel in “Break Panel” mode, call the ShowBeakForm method instead of ShowPopup.

Buttons

As you know, WinForms buttons can include shadows, rounded corners, convex backgrounds, etc. Though these UI elements are somewhat new, nothing innovative has been introduced for a Windows button in quite some time. A button is basically a border, an image, a text string, and a single "Click" event.

Thanks to the evolution of UI design (and of course, the PaintStyle property implemented by our developers), you can now eliminate Simple Button borders. This simple change adds elegance to an app and allows you to use Simple Buttons for completely new usage scenarios. For instance, by eliminating borders, you can now create flat toolbars without a need for our WinForms Bar Manager component.

The image below is a screenshot of a sample app I recently sent to one of our customers. He wanted to create a custom vertical toolbar with folding categories. As you can see, our Accordion Control delivers the required element hierarchy. Its content container items host WinForms Stack Panels, and each Panel includes a collection of Simple Buttons with a Light paint style. If you have a similar UI requirement, implementation is a breeze.

Your Turn

In my next post, I’ll discuss other new UI controls you may want to consider for upcoming WinForms projects. In the meantime, please comment below and let me know which new WinForms control you’ve used recently and why. Long live WinForms!

As I'm sure you are aware, Microsoft have announced that .NET 5 would be the next major release of the .NET Core ecosystem after .NET Core 3. Since development of the .NET Framework itself has been halted (apart from bug fixes, etc) at v4.8, they've dropped the "Core" name from .NET 5 since it and its successors will be the only .NET going forward.

Although still in Preview mode, with a projected release date in November 2020, .NET 5 includes many new enhancements that will make your applications and development process better and easier.

.NET Schedule

• .NET Core 3.0 was released in September 2019.
• .NET Core 3.1 was released in November 2019, and falls under the Long Term Support (LTS) program.
• .NET 5.0 will be released in November 2020.
• Major releases of .NET will occur every year, and Microsoft have stated that even-numbered releases will fall under the LTS program.
• Microsoft are emphasizing a predictable schedule, with minor releases if needed.

With regard to .NET 5, Microsoft have published a series of preview versions (1, 2, 3, 4, 5, 6). With each new preview release, we have been testing our components and libraries to support the changes within .NET 5.

DevExpress v20.1.6 supports .NET 5

Today, we are pleased to announce that DevExpress controls, components, and frameworks from v20.1.6 onwards are officially compatible with .NET 5 preview 6 or later. You can download them early next week (20 or 21 July) from both the Download Manager and NuGet.

If you are ready to experiment and try out .NET 5, here's a quick synopsis of what you will need to do.

Prerequisites

• To use .NET 5.0, you will need Visual Studio 2019 v16.6 or later.
• Make sure you've downloaded the latest .NET 5.0 Preview.

Move your app to .NET 5

If you have an application that uses .NET Framework and not .NET Core, you will have to migrate it to .NET Core 3 first. After which...

If you have an application that uses .NET Core 3, follow the steps below:

• Change the Target Framework to specify it as net5.0:

  <Project Sdk="Microsoft.NET.Sdk">    
      <PropertyGroup>
          <OutputType>Exe</OutputType>
          <TargetFramework>net5.0</TargetFramework>
      </PropertyGroup>
  </Project>
  

• In Visual Studio, go to Tools> Options> Preview Features and select the Use previews of the .NET Core SDK option (and, as it indicates, you will have to restart Visual Studio before doing any further work):

Desktop Enhancements

.NET Core 3 already supports desktop platforms such as WinForms and WPF. .NET 5 adds support for UWP (WinUI) and Xamarin (Maui), includes new .NET APIs, and extends the features for desktop development.

WPF

Visual Studio v16.3 allowed you to use a new XAML Designer for WPF .NET Core applications. We tested this XAML Designer with our WPF controls in .NET 5, and we are pleased to announce they fully support the XAML Designer features available for .NET Core.

Visual Studio v16.5 added a new feature called Suggested Actions. These actions give you easy access to the most used properties of a control selected within the XAML Designer. We are still exploring whether we can support Suggested Actions within DevExpress WPF controls.

Documentation: DevExpress WPF Controls - .NET Core Support

WinForms

Support for WinForms with .NET Core is, shall we say, a little more complicated. Microsoft announced that you can use the Windows Forms Designer for .NET Core projects in Visual Studio v16.6:

As you can see, the Designer renders forms already created using our controls correctly. However, the current version still does not offer the required extension APIs in order to fully support DevExpress design-time features, including Toolbox. Microsoft have stated that this required support for third party controls is coming, and we are providing input to that team when we can and when asked.

At present, you can use the workarounds demonstrated in the Using the WinForms designer for .NET Core projects section of this official blog post by Microsoft: How to port desktop applications to .NET Core 3.0.

We recommend that you use the second workaround from that post:

"You can have two project files in the same directory as your WinForms project: the old .csproj file from the existing .NET Framework project and the new SDK-style .csproj file of the new .NET Core WinForms project. You’ll just have to unload and reload the project with corresponding project file depending on whether you want to use the designer or not."

Again, we are working closely with Microsoft to ensure that the Windows Form Designer fully supports our WinForms controls for .NET 5 projects. We have no schedule as to when that support will be available.

Documentation: DevExpress WinForms Controls - .NET Core Support

Other Enhancements

Microsoft has clearly stated that .NET 5 is the sole future of the .NET family. All significant enhancements and new features to .NET will be part of .NET 5 and its successors, including language changes, runtime capabilities, and much more:

• .NET 5 includes C# 9. C# 9 has numerous enhancements including records, top-level statements, improved pattern matching, and more. To learn all about what’s coming with C# 9, refer to Mads Torgersen's Welcome to C# 9 post.
• .NET 5 allows you control over different runtimes.
• Additional benefits with .NET 5 include Core Runtime & API Performance enhancements, and deployment flexibility.

Microsoft recommends that developers build new applications with .NET Core 3.1 and then migrate them to .NET 5.

Globalization issues

.NET 5 Preview 4 introduced the use of International Components for Unicode (ICU) globalization APIs by default on Windows 10 1903, or later. (For more information, see Globalization APIs use ICU libraries on Windows.) However, there is currently a bug that Globalization does not read user setting overrides for current cultures when using ICU. As a result, our controls do not apply these overrides. Microsoft is expected to fix this bug in Preview 8.

As a workaround, you can continue using NLS globalization APIs. Set a run-time switch to revert back to the ICU behavior.

Conclusion

Without a doubt, we at DevExpress are excited about .NET 5 and the future of the .NET and Visual Studio stack. I hope this blog post about where we currently stand with .NET 5 was helpful: we're keeping up but there's still a lot to do! As always, we welcome any feedback: feel free to post comments below, or contact us via the DevExpress Support Center.

XAF v20.1.6 ships with a number of new features and stability fixes for Blazor UI. 

• Download DevExpress Components v20.1.6
• XAF Blazor Demo: Online | Download
  
• FAQ: XAF ASP.NET Core Blazor Server UI (CTP)

Blazor UI: Non-Persistent Objects

Blazor UI allows you to display and edit business objects that are not connected to a database table: Non-Persistent Objects. 

Blazor UI: Unsaved Data Confirmations

If unsaved data exists, a confirmation message is displayed before end-users can leave or reload a webpage. 

Blazor UI: Enhanced Validation Messages

Each validation message is now displayed within a floating panel. Its color and associated icon identify the rule: Error, Warning or Information. Warnings can be ignored. 

Action Permissions

Role detail views now include a Denied Actions tab. With it, administrators can hide Action availability for specific users: Security System - Action Permissions.

Model Editor for .NET Standard

The DevExpress .NET Framework Unified installer now includes a Model Editor for .NET Standard projects. In previous versions, this was only available with our .NET Core Components installer (learn more).

Known Issues

To review our list of known/resolved issues, please refer to the following article: FAQ: XAF ASP.NET Core Blazor Server UI (CTP).

Your Feedback Matters

As always, we welcome your thoughts. Please comment below and let us know what you think of these new features. Should you have technical questions, feel free to contact us via the DevExpress Support Center. 

XAFers Community StandUp in Zoom and Chats 

Jose Columbie and Joche Ojeda host live webinars on XAF, XPO and related topics from April: https://www.meetup.com/Arizona-XAFers-User-Group/events/past/ (each webinar ~2 hours). Jose and Joche discuss XAF/XPO best practices, their past and recent development experiences, and also demo interesting work projects. Dave Hesketh and Manuel Grundner - both DevExpress MVPs - are often among guests or presenters. 

I attended 2 webinars and especially liked the most recent presentation: July 9th 2020 - Best Practices. I am also going to participate in the next event where I will be answering questions and commenting on discussion topics.

You can also forward general questions to the XAF community via the chat group at https://gitter.im/XAF-Community/community. XAF MPVs, experienced XAF developers and I will share development experiences with you on this chat platform.

Jose Columbie also consolidated XAF community information in one location: https://github.com/jjcolumb/awesome-xaf - feel free to read or contribute.

Active YouTube Channel on XAF, XPO, Xamarin from Joche Ojeda

As you might recall, Joche is a DevExpress MVP who has been using XAF for almost 10 years. His XAF Facebook developer group for the Spanish-speaking community (https://www.facebook.com/xafes/) has nearly 400 members. Joche also does XAF/XPO consulting and custom development for companies in Europe, North and Latin America: https://www.bitframeworks.com/.

Joche published multiple XAF Blazor-related videos recently on his YouTube channel:

• XAF Blazor Signature Property Editor Web & Mobile (Teaser)
• XAF Blazor Google Maps Property Editor (update) & Waze integration
  
• XAF Blazor Google Maps Editor Web & Mobile (Teaser)
• XAF Blazor apps hosted on Linux (Ubuntu)

He has a hundred+ videos on XAF, XPO, Xamarin and other topics, so feel free to watch.

Of course, you can also find official videos on XAF at https://www.youtube.com/user/DeveloperExpress/videos. Our recent additions are:

• XAF Security: .NET User Authentication & Group Authorization API for EF Core in Blazor Server Apps
• XAF Security: Overview of .NET User Authentication & Group Authorization API for EF Core and XPO ORM

New Unit Testing Content

Check out the following new blog post on unit testing from Manuel Grundner (DevExpress MVP): Tasty - Delicious dotnet testing.

Our documentation contains more information on Unit Tests. These articles will be of importance for those creating complex apps with XAF. Please let us know what you think of these learning materials.

XAF Jobs, Contractors, Consulting and Development Services

If you are looking for custom XAF development or training, check out these third-party services. For instance, I heard many positive user comments on Llamachant, BitFrameworks or DevPark.

You may also want to check a third-party web site for XAF experts to find jobs, employment and career opportunities. This may be a good alternative to Upwork, Freelancer and other sites I mentioned in my old blog. From the site's description: "Xafers.Jobs is a job service that provides xafers with pre-screened XAF jobs leads that offer real pay for real work. From web to windows to mobile, from reporting to dashboards, all of the job openings we bring you offer some form of our loved XAF framework".

New XAFARI Version with XAF Modules Is Out

A new version of XAFARI that works with v20.1.4 is available and the v20.1.6 build is on its way too. Galaktika Soft has been providing paid reusable XAF modules with documentation and support services for more than 6 years.

New eXpand Framework Modules

The eXpand Framework, managed by Apostolis Bekiaris, continues to release new platform-agnostic packages for XAF: http://xaf.expandframework.com/.

• Office.Cloud.Microsoft - authenticates against Azure Active Directory and adds API for querying the Microsoft Graph endpoints.
• Office.Cloud.Microsoft.Todo - integrates with the Microsoft 365 To Do cloud service.

With the raise of Microsoft Teams (and similar tools) we anticipate that XAF integration with remote communication and collaboration services will be in high demand in the coming months.

Noteworthy Support Center Tickets and Dev Tips & Tricks Every Month

Every month, we publish links to interesting support questions submitted via the DevExpress Support Center (as well as documentation updates and development news) in our Tips & Tricks blog series. In it, you will learn what other users are doing with XAF, XPO and enrich your toolbox with shortcuts like FirstOrDefault<ObjectType>(Expression<Func<ObjectType, Boolean>>) or CustomizeViewItemControl(DetailView, Controller, Action) that save development time.

Our most recent release (v20.1) ships with an extended Shape API for our Word Processing Document API and Rich Text Editors (WinForms and WPF). This new API allows you to execute the following actions:

• Create different shapes (rectangles, lines, arrows, callouts, etc.)
• Position shapes on a page
• Change a shape’s fill and outline
• Group and ungroup shapes
• Remove shapes from a document.

Create and Format Drawing Objects

To demonstrate the capabilities of our Shape API, we’ll create the following simple flowchart:

1. Use the ShapeCollection.InsertPicture method to add a picture to a document. This will be the first block in our flowchart.

   Document document = wordProcessor.Document;
   // Set measurement unit to inches.
   document.Unit = DevExpress.Office.DocumentUnit.Inch;
           
   // Insert a picture.
   Shape block1 = document.Shapes.InsertPicture(document.Range.Start,
   	DocumentImageSource.FromFile("Picture_Block1.png"));
   // Specify picture position relative to the top left corner of the page.
   block1.Offset = new PointF(1.0f, 0.5f);

2. Use the ShapeCollection.InsertShape method to create a shape (an arrow in our example). The method includes parameters to help you specify a shape’s geometry, size, and location.

   // Create an arrow and specify its location and size.
   Shape arrow = document.Shapes.InsertShape(document.Range.Start,
   	ShapeGeometryPreset.RightArrow, new RectangleF(3.1f, 0.9f, 0.5f, 0.5f));
   // Apply a gradient fill to the arrow.
   arrow.Fill.SetGradientFill(GradientType.Linear, Color.FromArgb(0xA5, 0xA5, 0xA5),
   	Color.FromArgb(0x6E, 0x6E, 0x6E));
   // Remove the outline.
   arrow.Line.Fill.SetNoFill();

3. Call the ShapeCollection.InsertTextBox method to insert a text box. This will be the second block in our flowchart. Use the Shape.ShapeFormat.TextBox.Document property to access and modify text box content.

   // Create a text box and specify its location and size. 
   Shape block2 = document.Shapes.InsertTextBox(document.Range.Start,
   	new RectangleF(3.7f, 0.5f, 2f, 1.25f));
   // Change text box geometry.
   block2.ShapeFormat.Preset = ShapeGeometryPreset.RoundedRectangle;
   // Fill the text box with a specific color.
   block2.Fill.SetSolidFill(Color.FromArgb(0x92, 0xD0, 0x50));
   // Remove the outline.
   block2.Line.Fill.SetNoFill();
   // Access text box settings.
   DevExpress.XtraRichEdit.API.Native.TextBox textBox = block2.ShapeFormat.TextBox;
   // Specify text box content.
   SubDocument textBoxDocument = textBox.Document;
   textBoxDocument.AppendText("Step 2");
   // Align text horizontally and vertically.
   textBoxDocument.Paragraphs[0].Alignment = ParagraphAlignment.Center;
   textBox.VerticalTextAlignment = VerticalTextAlignmentType.Center;
   // Change text size and color.
   DocumentRange range = textBoxDocument.Paragraphs[0].Range;
   CharacterProperties cp = textBoxDocument.BeginUpdateCharacters(range);
   cp.ForeColor = System.Drawing.Color.White;
   cp.FontSize = 28;
   textBoxDocument.EndUpdateCharacters(cp);

Group and Ungroup Shapes

The ShapeCollection.InsertGroup method allows you to create a shape group. Use the Add methods of the Shape.GroupItems collection to add shapes and pictures to the group.

The example below describes how you can generate the following shape group:

Document document = wordProcessor.Document;
// Set measurement unit to inches.
document.Unit = DevExpress.Office.DocumentUnit.Inch;

// Insert a shape group.
Shape group = document.Shapes.InsertGroup(document.Range.Start);
// Specify group position relative to the left and top edges of the page. 
group.Offset = new PointF(1f, 0.5f);
            
// Access the group items collection. 
var groupItems = group.GroupItems;
// Add a rectangle to the group.
NestedShape shape1 = groupItems.AddShape(ShapeGeometryPreset.RoundedRectangle, 
	new RectangleF(0f, 0f, 2f, 1.25f));
shape1.Fill.SetSolidFill(Color.FromArgb(0x4F, 0x81, 0xBD));
shape1.Line.Fill.SetNoFill();

// Add an arrow to the group.
NestedShape shape2 = groupItems.AddShape(ShapeGeometryPreset.RightArrow, 
	new RectangleF(2.1f, 0.4f, 0.5f, 0.5f));
shape2.Fill.SetSolidFill(Color.FromArgb(0xA5, 0xA5, 0xA5));
shape2.Line.Fill.SetNoFill();
            
// Add a second rectangle to the group.
NestedShape shape3 = groupItems.AddShape(ShapeGeometryPreset.RoundedRectangle, 
	new RectangleF(2.7f, 0f, 2f, 1.25f));
shape3.Fill.SetSolidFill(Color.FromArgb(0x92, 0xD0, 0x50));
shape3.Line.Fill.SetNoFill();

Ungroup Shapes

Use the GroupShapeCollection.Ungroup method to split a group into individual shapes.

group.GroupItems.Ungroup();

Delete Shapes

The following example demonstrates how to remove shapes from a document:

// Delete the first shape in the collection.
document.Shapes.RemoveAt(0);

// Remove a specific shape from the collection.
document.Shapes.Remove(document.Shapes["Rectangle 1"]);

// Clear the entire collection.
// document.Shapes.Clear();

Your Feedback Matters

As always, we welcome your thoughts. Please comment below and let us know what you think of our new Shape API.

Should you have technical questions, feel free to contact us via the DevExpress Support Center.

As you may know, we’ve been improving DevExpress Dashboard’s asynchronous data processing capabilities in recent release cycles. We continue to invest resources in this area and thanks to some great feedback, we’ve further improved asynchronous data processing for supported desktop platforms (WinForms / WPF).

v20.1.6 includes the following Async-related changes to our Dashboard’s desktop controls (WinForms Dashboard Designer and Dashboard Viewer, WPF Dashboard Control).

What Has Changed?

We removed data calculations and data requests from the UI thread. With v20.1.6, Desktop Dashboard controls execute these operations without UI thread locking. To explore the impact of this change simple...

Open a Dashboard

Change the DashboardParameter value

Call the ReloadDataAsync method

As you can see in the animations above, the Dashboard’s interface is no longer locked and it now displays a loading indicator to provide visual feedback to end users.

This change is available out-of-the-box and does not require any modifications to your code.

Feedback

We’re let you go, please take a moment to share your thoughts on this implementation and tell us more about the platforms you currently target.