Last week, John and I where in Oslo for the NDC Oslo 2018 Edition.

It was, as expected, a big and awesome conference with top speakers and a lot of attendees. Some of the speakers stopped by our booth to say 'hi'.

There was a lot of interest in our v18.1 release, and a ran demos on all of our products. On the second day there was the attendee party with the best Norwegian 80's & 90's cover band Loveshack.

We organized daily raffles for DevExpress backpacks or even a platform subscription of choice!

To find out what NDC Oslo was all about, check the pictures below to get an impression:

We recently published a BenchmarkDotNet-based benchmark on GitHub: https://github.com/DevExpress/XpoNetCoreDemos/tree/master/ORMBenchmark.

We used it to test the performance of the following Object-Relational Mapping (ORM) libraries for .NET Framework 4.6.1 and higher:

• Entity Framework 6.0.2 (EF 6);
• Entity Framework Core 2.0.3 (EF Core); 
• eXpress Persistent Objects™ 18.1.3 (XPO). 

You can run the benchmark tests or review our results here. Needless to say, the lower the execution time the better. Example:

All benchmarks were executed using .NET 4.6.1, AnyCPU release builds (include warm-up), Windows 10 Enterprise x64, local Microsoft SQL Server 2016 Developer Edition, i7-7700 CPU @3.6GHz / 16GB RAM / SSD. Please note that DevExpress.Xpo and other referenced libraries will automatically be restored from Nuget. Edit the connection string in the App.config file, update the ORM library and target framework versions, if necessary. 

Your feedback is needed!

We kept the first version of this test as simple as possible.  Feel free to make data model and test case modifications to cover additional usage scenarios. For instance,  measure memory consumption, include scenarios with BLOBs, reference and collection properties, etc. We'd love to hear your feedback about this project. Drop us a line below, thanks.

See Also

XPO ORM Library – Available Free-of-Charge in v18.1!

Love XPO and want to help us promote it? Add the package through Nuget.org instead of DevExpress Nuget!

From June 25th until June 28th, another great event is taking place. This time John and I will head to Nuremberg Germany for DWX Developer Week edition 2018.

We'll be there showing you all the new features that come with our v18.1 release and handing out our free Eat-Sleep-Code T-Shirts. We will also do our daily raffles where you could walk off with a DevExpress platform subscription or one of the original DevExpress Backpacks. I will also have session about .NET Core and Dependency Injection.

If you're attending to Developer week, make sure to pay our booth a visit.

For our recent v18.1 release, we implemented Excel-style group filtering in the Pivot Grid Control. This feature shows a filtering popup that includes values from multiple columns in a hierarchical selection list. It allows end-users to select multiple column values for filtering.

Since many of our data-aware controls share basic concepts and architecture of their feature sets, we decided to enable the same group filters for the Tree List Control:

Please help us decide

Now, we’re considering to implement the same feature in the Data Grid. However, we would really appreciate some feedback before we do that. Do you use Excel Group Filters in the Tree List? Do you think you will use them in the Data Grid? Are there any specific use cases or scenarios that are not covered by the implementation you see above? Please share your thoughts with us and help us design this feature as you need it!

Disclaimer

The specifications/features outlined in this blog post are subject to change.

Our WPF team has begun work on a WPF Gantt component. To make certain the product we deliver addresses your business needs, we thought it important to share its capabilities with you and to solicit your feedback. Our objective is to create the best possible product – with your help, we expect to ship a CTP by year end and officially release the product in the first half of 2019.

Core Functionality

The DevExpress Gantt Control will consist of a Tree List (hierarchical grid with columns) on the left and the Gantt region on the right:

This layout will be familiar to those of you using Microsoft Project. Though similar from a UI perspective, our intent is not to blindly replicate Microsoft Project. If Microsoft ships a feature, it does not mean we will incorporate like functionality in our Gantt Control.  

Gantt Area

The Gantt area will be able to display Tasks, Summary Tasks, and Milestones.

All these elements will include predefined appearance settings (based upon the currently selected theme) that will be customizable with styles and templates. You will also be able to define a template for the content displayed next to a task.

The Gantt area will reuse visual elements (UI Virtualization) and will be able to handle 10000 tasks without performance issues.

Time Scale

You will be able to modify zoom factors - displaying tasks within a specific date range.

The time scale will also be customizable. You will be able to display/hide weekends, highlight holidays and special dates (Strip Lines).

Task Progress

Every task will include a progress value. This will be displayed as a progress bar within the Gantt area.

Task Predecessors

Each task will have one or more of the following predecessor types: SS, SF, FS, FF (see https://en.wikipedia.org/wiki/Dependency_(project_management) for more information). Tasks will be connected to their predecessors visually within the Gantt area.

Resources

You will be able to assign one or more resources to a task. Resource names will be displayed next to tasks in the Gantt area.

Tree List Area

The Tree List will be customizable. You will be able to modify settings, add new columns, or customize existing options.

Data Binding

The DevExpress Gantt Control will be a data aware control – it will not have its own item collection. You will be able to assign your data objects to the ItemsSource collection and specify mappings to bind task properties (StartDate, EndDate, etc.) to your data source fields.

To define the task hierarchy, you will be able to use mappings (Id and ParentId for flat sources and Children for hierarchical sources) or return children in code.

We will also provide built-in data objects (GanttTask, GanttResource, GanttPredecessor) for those who do not already have types for Gantt elements. If you assign a collection for these objects to the ItemsSource property, you will not need to specify mappings.

The Gantt Control will listen to changes in bound objects and update its state accordingly.

Editing

We will start with a read-only Gantt and work on editing once the UI/presentation is complete. You will always be able to manually edit a task via a dialog.

Undo/Redo

We will not provide global Undo/Redo functionality. This would introduce a degree of complexity and a set of restrictions (both during development and for end-users) we wish to avoid at this stage.  

Once we support editing in the Tree List, you will be able to cancel your changes before navigating away from the edited task.

Validation

We will consider validation (displaying errors for overlapping dates, busy resources, etc.) when we support editing.

Automatic Scheduling

When we support editing, we will also implement automatic scheduling for tasks – calculating StartDate/EndDate/Duration based on partially specified properties and defined Predecessors.

Import/Export

Since the Gantt control will work with external data, it will not feature built-in import/export to/from XML. However, it will be easy to manually parse an XML file from Microsoft Project and create task objects (since our Gantt Control uses similar terminology). It’s likely that we will create an example or a helper class for this feature.

Scheduler Integration

The Gantt Control will not use Scheduler objects and vice versa. However, since both controls can be bound to data, you will be able to display your objects in both the Gantt and the Scheduler.

Printing and Export

It will be possible to export and print the Tree List area of the Gantt control. We will not introduce printing functionality for the Gantt area until its UI/presentation and data editing functionality are complete.

Other Features

We consider these features less important, optional, or easy to implement on the client side. We will not be focused on these during our initial development phase.

• Built-in task edit form
• Built-in Ribbon
• Constraints for automatic scheduling
• Baseline
• Resource view (displaying multiple tasks in a single row)
• Timeline
• Recurring Tasks

Your Feedback is Important

As mentioned at the beginning of this blog post, DevExpress wants and needs your feedback. If you’re interested in a WPF Gantt control or have used one in the past, please take a moment to comment here or write to us at support@devexpress.com. We want to know more about your business needs, use cases and how you would benefit from a product like this in a production environment.

A note to our WinForms users

If you’re using WinForms and are wondering if we have similar plans for the WinForms platform, the answer is yes. Our decision to pursue this product for WinForms is predicated upon the feedback we receive from WPF users.

CodeRush has recently changed the way it reads and processes your options, adding new layers which make it much easier to bind settings to a particular solution or team. This post will explain those changes and show how you can get the most out of this new functionality.

How did Options previously work?
CodeRush used to just store a single set of options in a single place.
This made is easy to backup your options and take them with you, or have them easily replicate to different physical locations (Office, Home, Laptop)

While this on its own is awesome, we wanted to do more.

For example, you might want to:

• Share options with team developers working on the same solution. It's always helpful if as many people as possible can create and manipulate code according to a single standard and set of pre-configured tools.
• Use different options for different solutions. Not everyone works for a single employer or sits on a single team where standards are universally agreed. Also, it often makes sense to have the same Template Name Variable shortcut reference different classes in different solutions (for example, you might want "bb" to reference your custom "BigBus" class in one solution, while referencing your custom "BelgianBeer" class in another).
• Override select team options, templates, shortcuts, etc. on a personal basis. 

How do the new settings work?
The new Options layer lets you create and easily manage multiple sets (or partial sets) of options layers, which we combine at the appropriate times to provide you with a truly seamless experience.

We pull options from at least three distinct layers and compose them for you so that you get the experience you need.

The three layers are:

Solution Personal Options: This is the first place CodeRush looks for options. If it finds that you have personally overridden an option, it looks no further and applies that option to your session. These options are found within the ‘.cr\personal’ folder in your solution folder. Note: if you use these options, your personal overrides should be excluded from source control. These are intended to represent your personal preferences on the given solution, and as such, it's probably a good idea to NOT force them on your colleagues. 

Solution Team Options: Assuming no Solution-based Personal override options are found, CodeRush looks to the Solution-based Team options. These are found within the ‘.cr\team’ folder beneath your solution folder. Note: Now this folder we do recommend adding to source control, so that team options can percolate throughout everyone on your development team.

Team settings are a great place to establish a consistent coding style. Variable naming conventions, brace positioning, indentation style and other vitally important determinations make sense here.

Personal Options: If CodeRush does not find any Solution-based options (personal or team) , then it will look at your traditional CodeRush settings. I like to think of this as the machine level options, since I’m the only one who uses my machine.

There's actually a fourth layer, which are the default settings that come with CodeRush out of the box.

So how do I modify the options in each of these layers?

I’m so glad you asked.

As always, your options can be accessed from the CodeRush | Options... menu.

When you reach the Options Dialog, you will notice a new section at the bottom allowing you to indicate which layer to save any current option changes. This defaults to your Personal Options layer. This is the same location where previous versions of CodeRush have saved their options.

Options Layers

Alternatively (and perhaps more interestingly), you can visit the options by way of our new Options Layers... menu option:

This will present you with our new Options Layers window.

Each of the listed entries in this window, when double-clicked, will launch the CodeRush Options dialog but only targeted at the layer in question, allowing you to see options at only that layer (and default values from layers below) and alter them in isolation for that targeted layer.

When the Options Dialog is launched in this manner, the previously-mentioned "Layer to save changes:" option will be gone. And there will be an additional section at the top left of the dialog, which will show you the currently targeted layer, as well as its physical location on disk.

When you save options in a dialog launched in this manner, the changes you make are only saved in the that targeted layer.

Custom External Option Sets

Obviously it would be a bit of a pain to have to setup your personal navigational options for each and every solution, so we give you the facility to add your own layers which are a higher priority than those that we ship.

If needed, you can create one or more independent folders containing personal overrides which you can store outside (independent of) any single solution, and attach it to one or more solutions, rather like enabling one or more sets of StyleCop rules.

To add a new custom layer:

1. Open the Options Layers dialog.
2. Select the layer you would like to override.
3. Click the "+" button.
   
   
4. Specify a folder. Either an empty one to store new settings, or a folder with pre-existing settings. 
   
   

At this point you’ll have several layers of options each contributing to your CodeRush experience:

1. Personal Options – Your default CodeRush options held at the user level for any given machine.
2. Solution Team Options – The options that you wish to impose on a team working on this solution, held within the ‘.cr\team’ subfolder underneath your solution.
   
3. Solution Personal Options – Your personal overrides for this particular solution, held within the ‘.cr\personal’ subfolder underneath your solution.
   
4. CodeRush Personal Settings – A prebuilt collection of settings that you prefer to be in place for a selection (but not necessarily all) of your solutions. these can be located anywhere convenient (like say a Dropbox or OneDrive folder).

So now you should have everything you need to operate with the correct settings under all circumstances. We hope you enjoy the new layers options, and if you have any questions don't hesitate to ask!

Every DevExpress release introduces some new major features that receive lots of attention in the run-up to the release. DirectX hardware acceleration, Fluent Design, vector icons and skins - you must have heard about those, if you’ve been reading our blogs and newsletters.

In addition to these big new features, we also continuously work on smaller details. In this post, I will point out a few features that you may have missed so far - hopefully they will make your developer lives easier!

Workspace Manager

You are probably aware that all major DevExpress controls - including Ribbon, Bars, Grid, Layout Manager, Document Manager and others - have a pair of SaveLayout and RestoreLayout methods. These helpers implement runtime settings persistence, storing changes to the registry, an XML file or a stream. In a large real-world application, this system still requires some code to be written to coordinate the persistence of the large number of individual controls. We offer a more elegant solution that automates this process further: the Workspace Manager.

This component saves and restores presets called workspaces, which include layout settings for all supported DevExpress controls in a hierarchy, usually for the main form. It even provides dedicated Toolbar and Ribbon items that enable end-users to capture their own workspaces, load and save them.

If necessary, you can restrict end users from loading any but the predefined workspaces, and there are also mechanisms that filter the set of components considered for persistence.

Find documentation for the WorkspaceManager here.

Input Box

When you need to show a message with a single editor so that a user can type in a value or select one from a drop-down list, you could create a custom User Control and display it using an XtraDialog for UI consistency. But it is even easier to use our XtraInputBox instead:

var result = XtraInputBox.Show("Enter a new value", "Change Settings", "Default");

The Input Box occupies the sweet spot between a simple message box and a full-fledged dialog. You can choose any DevExpress editor to display, and customize it if required.

Documentation for the XtraInputBox is available here.

In addition to the Input Box, the DevExpress WinForms Subscription includes all the tools to replace standard message boxes, dialogs, hints, alerts, toast notifications, and file/folder selection dialogs with their skinned counterparts. You can see a complete list on this documentation page.

Behaviors

When our new Skin Editor was released, many customers asked us to make its Magnifier available as a separate control, since it complements color pickers nicely. We decided to introduce the Magnifier as a Behavior that can be attached to any ColorEdit descendant, providing an extra button for the editor that brings up the Magnifier.

There are currently twelve other Behaviors that extend or modify an attached control. For instance, the Clock Behavior styles a LabelControl or a digital Gauge as a clock:

The Stub Glyph Behavior provides placeholder icons for data records, layout items and tabs.

Note that the Persistence Behavior offers an additional approach for the settings persistence functionality described above! Documentation for all Behaviors can be found here.

If you come across a scenario that forces you to customize DevExpress controls in the same manner over and over again, please let us know and we will consider adding a new Behavior to get your job done more quickly and make the customization available to others.

Did you already know the three features mentioned in this post? We have a few more items and we will make at least a second post if you’re interested! Please share any thoughts you have, or let us know about other “easy to miss” features you have discovered yourself.

This week John and I were in Nuremberg Germany for the annual DWX Developer Week Conference.

We had quite some interesting conversations with existing customers and prospects primarily about DevExtreme, WPF and our WinForms controls. Also some of the speakers came down to our booth to catch up and to collect one of our ‘eat-sleep-code’ T-Shirts.

The last day of the conference was also the day that Germany had to face South Korea for the Soccer World Championship. After the lunch break, people where gearing up for that.

My session about dependency injection on .NET Core was well attended, and also our daily raffles where a hit!

Below is an impression of the conference:

                  

I hope we’ll meet at one of the upcoming conferences!

Want to expose your eXpress Persistent Objects™ (XPO) data model for CRUD operations through a lightweight JSON web service?

Our new Code Example implements a fully-functional OData V4 service with XPO and Web API. This solution relies on the Microsoft.AspNet.OData library, and is an alternative to our WCF-based XPO Data Service.  

Why drop the previous XPO Data Service (OData V3)?

• Functionality: OData V4 supports more features than OData V3: What’s New in OData Version 4.0.
  
• Maintenance: According to Microsoft documentation, all REST feature enchancements will be made for ASP.NET Web API.
  
• Flexibility: Web API Controllers are extension points, wherein you can add custom logic to manage/validate objects or customize a LINQ query.
• Compatibility: Since the OASIC committee accepted OData V4, it has become a worldwide standard. Many developers use OData V4 and your service will be compatible with their applications.
  

Like it?

We created this example based on requests received from users. We hope to refine it with community feedback. For instance, this boilerplate code can be automated using the wizard. Drop us a line below once you've had an opportunity to test this feature, thanks.

See Also

XPO ORM Library – Available Free-of-Charge in v18.1!

Love XPO and want to help us promote it? Add the package through Nuget.org instead of DevExpress Nuget!

  Uriah
  DevExpress Support
  XPO team

As with every planning phase we go through with regard to DevExpress Universal, we have a discussion about which versions of Visual Studio, C#, and .NET we should support in the proposed release. Our discussions about v18.2 (due in November or December this year) are no different.

After some back and forth between the relevant teams – WinForms, WPF, ASP.NET, XAF – we’ve decided to recommend the following as a minimum for our products going forward: .NET v4.5.2, Visual Studio 2015, and C# 6.

Executive summary

Let me quickly summarize the benefits and disadvantages of this recommendation, at least from an “executive” viewpoint:

1. Reduced Development Costs. Our teams will be able to use new .NET and C# features in their code. Certainly, the same functionality could be achieved with the current .NET and C# versions we support, but it does require additional resources/man-hours.

2. Improved Code Maintenance. With regard to our designers, templates, and so on, we are currently forced to support far too many environments and versions of Visual Studio. (For example, only a tiny fraction of our user base still uses and relies on Visual Studio 2012.) By reducing the number of versions we support – Visual Studio 2015, or later – we will simplify our internal tests and will not need to concern ourselves with how a given implementation works in older versions of Visual Studio/.NET.

3. Future Proof. .NET 4.0 was discontinued two years ago. Microsoft is no longer concerned about .NET 4 when it develops new features or applies security fixes. The longer we (and you!) wait, the harder the migration process will be.

Technical rationale

With regard to a more technical perspective, here’s why we’re going for the versions we’re choosing:

.NET 4.5.2

Pros:

1. Actively maintained. Microsoft dropped .NET 4, 4.5, and 4.5.1 support over two years ago (see https://support.microsoft.com/en-us/help/17455/lifecycle-faq-net-framework). All newer security patches are only applied to .NET 4.5.2 and higher.

2. Startup Performance. The Native Image Task available in modern operating systems (that is, Windows 8 or later) can automatically generate native images for assemblies that target .NET 4.5.2. This can improve startup performance on machines where our libraries are installed into the GAC.

3. New Features.eXpressApp Framework’s Mobile UI depends on WCF Data Services for the backend. Known limitations exist, but with .NET 4.5 or higher, we will use ASP.NET Core’s infrastructure and features (API Controllers, dependency injection, security, etc.). .NET 4.5 also opens opportunities for .NET Standard support in certain XAF modules (common code between different .NET platforms).

4. Simplified Demos, Documentation, and Code Examples. We will be able to use the .NET/C# async feature instead of Tasks in the code examples and demos we prepare for all of you.

5. Reporting. The reporting team will be able to integrate Code Completion for scripts in our Report Designers by using Roslyn support (Roslyn requires .NET Framework 4.5.2). Currently this same feature requires an internet connection (even for custom assemblies developed by our customers) to our hosted service for the same functionality. 

Cons:

1. You will not be able to run your applications on Windows XP.

2. MVC 4 will not be supported by our ASP.NET MVC server-side extensions.

C# 6

Pros:

1. Performance. We currently need to determine the caller info in certain segments of our code. The introduction of Caller Information will allow us to do this slightly faster.

2. Simplified Demos, Documentation, and Code Examples. We will be able to use new C# features to simplify both our code base and the code that we provide to you. The most important feature introduced in C# 5 was async, and the most useful features in C# 6 are: null-conditional operators, nameof expressions, and expression-bodied members.

3. Simplified API. Thanks to .NET’s Caller Information feature, certain methods (e.g., the SetProperty/GetProperty methods in our MVVM Framework or the SetPropertyValue/GetPropertyValue methods in our XPO ORM library) will not require us to pass the property name as a parameter.

4. Code Stability. C# 5 fixes certain compiler issues that we currently work around in our code (JIT inlining, IL verification).

Cons:

1. You will not be able to use Visual Studio 2010, 2012, or 2013 to recompile our source code, however you will still be able to use our pre-compiled assemblies in Visual Studio 2012 and 2013.

Feedback needed

It is without a doubt that some of these proposed changes could affect some of our customers. We do believe however that they are necessary in order to help us and you keep abreast of the latest developments in the .NET space (remember, more news about .NET Core 3 is on its way), and to help us reduce the burden of having to support such a wide breadth of .NET/C#/Visual Studio versions with a single codebase.

If you do have some feedback on these proposals, please email either our management team (management@devexpress.com) or myself (julianb@devexpress.com).

In the week of May 21st, John, Julian and I where at the Techorama 1018 event in Antwerp, Belgium.

As always, it was a very good conference with lots of existing customers and developers who haven’t heard of us. We were able to show a lot of new v18.1 features and people seemed to like those. I did a well attended partner-session about our VisualStudio productivity tool CodeRush, where I was able to get the “Wow” and “Ahh” responses from the audience.

Below is an impression of the conference:

In case you missed this one and want to attend a Techorama conference. In the first week of October there will be anotherTechorama conference in Ede, The Netherlands.

Guess what? . . . DevExpress will be there as well!

As with every planning phase we go through with regard to DevExpress Universal, we have a discussion about which versions of Visual Studio, C#, and .NET we should support in the proposed release. Our discussions about v18.2 (due in November or December this year) are no different.

After some back and forth between the relevant teams – WinForms, WPF, ASP.NET, XAF – we’ve decided to recommend the following as a minimum for our products going forward: .NET v4.5.2, Visual Studio 2015, and C# 6.

Executive summary

Let me quickly summarize the benefits and disadvantages of this recommendation, at least from an “executive” viewpoint:

1. Reduced Development Costs. Our teams will be able to use new .NET and C# features in their code. Certainly, the same functionality could be achieved with the current .NET and C# versions we support, but it does require additional resources/man-hours.

2. Improved Code Maintenance. With regard to our designers, templates, and so on, we are currently forced to support far too many environments and versions of Visual Studio. (For example, only a tiny fraction of our user base still uses and relies on Visual Studio 2012.) By reducing the number of versions we support – Visual Studio 2015, or later – we will simplify our internal tests and will not need to concern ourselves with how a given implementation works in older versions of Visual Studio/.NET.

3. Future Proof. .NET 4.0 was discontinued two years ago. Microsoft is no longer concerned about .NET 4 when it develops new features or applies security fixes. The longer we (and you!) wait, the harder the migration process will be.

Technical rationale

With regard to a more technical perspective, here’s why we’re going for the versions we’re choosing:

.NET 4.5.2

Pros:

1. Actively maintained. Microsoft dropped .NET 4, 4.5, and 4.5.1 support over two years ago (see https://support.microsoft.com/en-us/help/17455/lifecycle-faq-net-framework). All newer security patches are only applied to .NET 4.5.2 and higher.

2. Startup Performance. The Native Image Task available in modern operating systems (that is, Windows 8 or later) can automatically generate native images for assemblies that target .NET 4.5.2. This can improve startup performance on machines where our libraries are installed into the GAC.

3. New Features.eXpressApp Framework’s Mobile UI depends on WCF Data Services for the backend. Known limitations exist, but with .NET 4.5 or higher, we will use ASP.NET Core’s infrastructure and features (API Controllers, dependency injection, security, etc.). .NET 4.5 also opens opportunities for .NET Standard support in certain XAF modules (common code between different .NET platforms).

4. Simplified Demos, Documentation, and Code Examples. We will be able to use the .NET/C# async feature instead of Tasks in the code examples and demos we prepare for all of you.

5. Reporting. The reporting team will be able to integrate Code Completion for scripts in our Report Designers by using Roslyn support (Roslyn requires .NET Framework 4.5.2). Currently this same feature requires an internet connection (even for custom assemblies developed by our customers) to our hosted service for the same functionality. 

Cons:

1. You will not be able to run your applications on Windows XP.

2. MVC 3 and 4 will not be supported by our ASP.NET MVC server-side extensions.

C# 6

Pros:

1. Performance. We currently need to determine the caller info in certain segments of our code. The introduction of Caller Information will allow us to do this slightly faster.

2. Simplified Demos, Documentation, and Code Examples. We will be able to use new C# features to simplify both our code base and the code that we provide to you. The most important feature introduced in C# 5 was async, and the most useful features in C# 6 are: null-conditional operators, nameof expressions, and expression-bodied members.

3. Simplified API. Thanks to .NET’s Caller Information feature, certain methods (e.g., the SetProperty/GetProperty methods in our MVVM Framework or the SetPropertyValue/GetPropertyValue methods in our XPO ORM library) will not require us to pass the property name as a parameter.

4. Code Stability. C# 5 fixes certain compiler issues that we currently work around in our code (JIT inlining, IL verification).

Cons:

1. You will not be able to use Visual Studio 2010, 2012, or 2013 to recompile our source code, however you will still be able to use our pre-compiled assemblies in Visual Studio 2012 and 2013.

Feedback needed

It is without a doubt that some of these proposed changes could affect some of our customers. We do believe however that they are necessary in order to help us and you keep abreast of the latest developments in the .NET space (remember, more news about .NET Core 3 is on its way), and to help us reduce the burden of having to support such a wide breadth of .NET/C#/Visual Studio versions with a single codebase.

If you do have some feedback on these proposals, please email either our management team (management@devexpress.com) or myself (julianb@devexpress.com).

This second Tips&Tricks post is all about application performance. We have some recommendations to share - hopefully they will help you increase performance of your own applications! The list starts with items that are generally applicable and should be considered for most, if not all, applications. Further down you find a few approaches that apply to specific use cases.

Upgrade to the latest DevExpress installation

It may seem cheeky to list this as the first item, but it is meant quite seriously: among the most effective things you can do to optimize performance for your application is to use our latest release. We constantly allocate significant developer time to an ongoing process of performance analysis and improvement. We often blog about specific performance achievements, but many individual points go unannounced!

As an example, we recently optimized our skinning mechanism to fill areas with solid colors when possible and avoid more expensive image drawing. For modern “flat” skins without gradients, this improvement is quite significant.

And now on to other suggestions!

Pre-compile your apps using NGen

This first tip applies to any Windows Forms application, whether you are a DevExpress customer or not.

When you build a .NET application in Visual Studio, it is compiled into Microsoft Intermediate Language (MSIL, sometimes IL for short). When a user launches the application, its MSIL code is compiled into machine code by the “just in time” (JIT) compiler. An important advantage of this approach is that the JIT compiler can employ optimizations depending on the user’s target platform, but the process can cause noticeable delays. External DLLs may be loaded in addition to your own application, which means that any delay doesn’t depend on the size of your code alone.

If you struggle with start-up delays in your application due to JIT compilation, you should utilize the Native Image Generator (Ngen.exe) tool in the .NET Framework SDK. This tool compiles the MSIL code in an assembly into native code just like the JIT compiler does, but you can control when this happens - for instance, you can run it as part of the installation process. When the end-user eventually runs your application, the CLR loads the precompiled code and no additional compilation is required.

Refer to this MSDN blog post for detailed information, or check out our Support Center ticket dedicated to NGen.

Try DirectX rendering

You can enable DirectX hardware acceleration to accelerate all painting operations and to benefit from high power graphics cards in end-user PCs. The benefits are greater when High DPI screens are being used, but even at standard DPI resolutions, output performance is improved. For instance, check out these GIF animations in our documentation to compare PictureEdit performance with and without DirectX when the editor shows large images. More details about DirectX support in our WinForms products, and a list of controls that benefit from it, are available at this documentation URL.

Use deferred loading

Deferred loading is a general-purpose technique that suggests to “load” (i.e. to create, instantiate or retrieve) information as well as costly UI elements only when it becomes clear that they are definitely needed. In other words, what an end user can’t see doesn’t need to exist (yet). This mindset is a good basic recommendation because an application that employs deferred loading tends to feel faster and snappier to the end user.

Some DevExpress controls have built-in support for deferred loading. For instance, the Document Manager component supports it based on the QueryControl event, loading only those documents that are visible at a certain point in time. Here is the documentation for the Document Manager feature. A very similar approach is also implemented in the Navigation Frame.

Load Data Grid images asynchronously

Another more specialized deferred loading mechanism is implemented in the Data Grid. If your grid is populated with records that include large (or several) images, you should definitely try the Asynchronous Image Load feature. With this feature enabled, the grid displays its UI - and supports user interaction! - without waiting for images to load. Images are loaded asynchronously and displayed with an optional animation effect when they become available.

The feature is highly customizable: you can cache images after the first load so they don’t need to be reloaded when the user scrolls the grid. The image loading order can be randomized, the loading indicator customized, or image loading overridden entirely for specific records.

Disable skins and visual effects

This last item is not a general recommendation, but it might be useful in specific scenarios. One example of such a situation is a Remote Desktop Services environment. In this setup, remote users constantly receive snapshots of an application’s visual appearance. The more visual effects the application has, the more updates are required. If the connection is poor and the refresh rate low, the application may seem unresponsive. In some low-performance environments you may run into similar issues, for example when you target embedded systems with WinForms applications.

To run DevExpress WinForms applications without optional visual effects, you can selectively take several steps on application start-up. As an example, this code snippet shows detection of a Windows Terminal Server session.

WindowsFormsSettings.LoadApplicationSettings();

if (System.Windows.Forms.SystemInformation.TerminalServerSession) {
  SkinManager.DisableFormSkins();
  SkinManager.DisableMdiFormSkins();
  Application.VisualStyleState = VisualStyleState.NoneEnabled;

  UserLookAndFeel.Default.UseWindowsXPTheme = false;
  UserLookAndFeel.Default.Style = LookAndFeelStyle.Flat;

  WindowsFormsSettings.AnimationMode = AnimationMode.DisableAll;
  WindowsFormsSettings.AllowHoverAnimation = DevExpress.Utils.DefaultBoolean.False;

  BarAndDockingController.Default.PropertiesBar.MenuAnimationType = AnimationType.None;
  BarAndDockingController.Default.PropertiesBar.SubmenuHasShadow = false;
  BarAndDockingController.Default.PropertiesBar.AllowLinkLighting = false;
}

Here are some details about aspects of this code sample:

LoadApplicationSettings - by default, options applied on the DevExpress Project Settings page are loaded from App.config during form initialization. This process would override options applied from code during application startup. An explicit call to LoadApplicationSettings applies the settings right away so that changes made in code after this call can take precedence.

WindowsFormsSettings.AnimationMode - this setting affects those control animation properties that have the default value DefaultBoolean.Default. If you manually enable specific animation effects (e.g. AllowSortAnimation in a Data Grid), the control-specific settings have priority over the global flags in WindowsFormsSettings.

Finally, note that if you use the Ribbon Control, it cannot be shown without a theme and it will always have at least the default DevExpress Style skin applied. It might be better to use the Bar Manager instead if you disable skins. This will result in a consistent UI and save significant resources, since the Ribbon consumes about twice as much memory as the Bar Manager.

Any thoughts?

Please let us know your own experiences with performance optimizations, or any thoughts you have about our suggestions! The more input we have from our customers, the more effective we can be with optimization work and future plans for performance specific features!

Now that the DXperience v18.1 release is available, let's dive into the new features of our Bootstrap Form Layout control.

The DevExpress ASP.NET Bootstrap Form Layout control helps you to build efficient and adaptive form layouts using the Bootstrap grid system.

Layout Groups

Let's start with the new 'Layout Groups' and 'Tabbed Layout Groups'. These Layout Groups serve as containers for Layout Items and allow you to create well organized forms that look great.

Tabbed Login Form

For example, you can easily create a "Login and Register" tabbed form with the Bootstrap Form Layout control. All you need is one tabbed layout group in the control’s Items collection with two layout groups: 'Login' and 'Register'. These groups contain layout items (with editors) to input typical data that's required to login or register for a website. Here's the sample code outline:

<dx:BootstrapFormLayout runat="server" ID="BootstrapFormLayout1">
	<Items>
		<dx:BootstrapTabbedLayoutGroup>
			<Items>
				<dx:BootstrapLayoutGroup Caption="Login">
					<Items>
						...
					</Items>
				</dx:BootstrapLayoutGroup>
				<dx:BootstrapLayoutGroup Caption="Register">
					<Items>
						...
					</Items>
				</dx:BootstrapLayoutGroup>
			</Items>
		</dx:BootstrapTabbedLayoutGroup>
	</Items>
</dx:BootstrapFormLayout>

Adaptive

The Bootstrap Grid system provides classes for different screen sizes. The DevExpress Bootstrap controls help you to leverage these features of the Bootstrap Grid system.

To help you make your layouts more adaptive, some of the layout items support BootstrapLayoutItem.ColSpanXl / ColSpanLg / ColSpanMd / ColSpanSm / ColSpanXs properties. This allows you to define different values depending on the current screen resolution. For example, here the layout changes column count based on the width:

Non-tabbed

Non-tabbed layout groups are useful to visually separate and group a form's sections without using tabs.

Before the v18.1 release, you would need several Form Layout controls to create non-tabbed layout groups. Now, you can add the required groups or another layout group’s Items collection to the control:

<dx:BootstrapFormLayout runat="server" ID="BootstrapFormLayout1">
	<Items>
		<dx:BootstrapLayoutGroup Caption="Registration form">
			<Items>
				<dx:BootstrapLayoutGroup Caption="Authorization Data">
					<Items>
						...
					</Items>
				</dx:BootstrapLayoutGroup>
				<dx:BootstrapLayoutGroup Caption="Personal Data">
					<Items>
						...
					</Items>
				</dx:BootstrapLayoutGroup>
				<dx:BootstrapLayoutItem ColSpanXs="12">
					...
				</dx:BootstrapLayoutItem>
			</Items>
		</dx:BootstrapLayoutGroup>
	</Items>
</dx:BootstrapFormLayout>

Take a look at all of the new features of our Bootstrap Layout control here: ASP.NET Core & WebForms Bootstrap – Layout Control Enhancements (v18.1)

Like it?

We'd love to hear your feedback about the new features of the DevExpress ASP.NET Bootstrap control. Drop me a line below, thanks.

Email: mharry@devexpress.com

Twitter: @mehulharry

We have received many comments and questions on our previous blog post. Thank you all for that!

In this post, I will describe our updated benchmark based on your feedback: 
    https://github.com/DevExpress/XpoNetCoreDemos/tree/master/ORMBenchmark

Let me remind that we have tested the performance of the following Object-Relational Mapping (ORM) libraries for .NET Framework 4.6.1 and higher:

• Entity Framework 6.0.2 (EF 6);
• Entity Framework Core 2.0.3 (EF Core); 
• eXpress Persistent Objects™ 18.1.3 (XPO). 

What's New in the benchmark?

1. EF benchmarks now use the AsNoTracking method in the Fetch, LinqQuery, InstantiationNative and other test cases. It has slightly, but not significantly decreased data reading time.
   
2. Since XPO has no option such as the EF's AsNoTracking, we created the additional ProjectionLinq benchmark that demonstrates how much time each ORM library takes to load objects without tracking changes.
   
3. For XPO benchmarks, we set the IdentityMapBehavior option to Strong. This allows us to reduce time to place loaded objects inIdentity Map.
4. Our short-time benchmarks (for example, InstantiationLinq and LinqTakeRecords* on small data set) are now more accurate because of improved the benchmark configuration. 

We also tried to use the Find method instead of First in the Fetch benchmark based on Neal's comment. In certain cases it showed lower performance, in others it did not affect the result much. As a result, we left the benchmark unchanged.

Run the updated benchmark tests or review our results here. Example: 

All benchmarks were executed using .NET 4.6.1, AnyCPU release builds (include warm-up), Windows 10 Enterprise x64, local Microsoft SQL Server 2016 Developer Edition, i7-7700 CPU @3.6GHz / 16GB RAM / SSD. Please note that DevExpress.Xpo and other referenced libraries will automatically be restored from Nuget. Edit the connection string in the App.config file, update the ORM library and target framework versions, if necessary. 

Your feedback is needed!

What do you think about this update? Did you try to extend this benchmark with your own scenarios? Let us know in comments. We'd love to hear your feedback and results.

See Also

• XPO - A simple benchmark against EF 6 and EF Core v1
  
• XPO ORM Library – Available Free-of-Charge in v18.1!

Love XPO and want to help us promote it? Add the package through Nuget.org instead of DevExpress Nuget!

  Yekaterina K.
  Technical writer
  XPO team

Logify allows you to create rules to automatically reject unnecessary/unwanted crash reports so you can concentrate on issues that matter most to your business. In addition to the productivity benefits inherent in this feature, Auto-Ignore Rules allow you to reduce the total incoming report count. This helps you save money because your Logify price plan limits are not wasted on unimportant reports.

In this blog post, I will briefly detail Logify’s auto-ignore settings.

Predefined Auto-Ignore Rules

Here are simple but effective auto-ignore filters you can activate using check boxes:

• Ignore known bots
  As you know, various bots (e.g. search engine crawlers) can visit your site. Their behavior can trigger missing page or script errors. As a rule, such issues are not of consequence for your website's users. Use this setting to filter out these reports automatically.
• Ignore 404 error
  You may choose to ignore all 404 errors on your website. If you understand the cause of such errors and it lies outside of your application's domain, it might make sense for you to disable this type of reports.
• Ignore .local domain and localhost
  Activate this setting if you don’t want to receive reports generated during debug sessions.
• Ignore reports without My Code
  This auto-ignore option allows you to reject reports that do not contain “your” lines in call stack. This feature can be useful when developing a component (a plug-in) for a large system. Logify will catch both your exceptions and those generated from other parts of the system. To reject crash reports you are not interested in, set the My Code rule to identify “your” call stack lines and enable this option.

Blacklist

You can filter out reports that include a specific string.

This option will be helpful for applications that support third-party plugins. If you receive crash reports about a plugin used by your application, you can reject related reports by extending Logify's Blacklist with strings that identify that plugin.

Call Stack Auto-Ignore Rules

Call stack rules are useful when you need to skip reports about known or fixed issues.

To enable this option, first locate an existing report that will serve as a template:

1. Select the call stack lines you want to locate in your Logify reports.
2. Specify whether Logify should pay attention to both distance between the lines and their order, or only their order.

Use this setting with caution as you may accidentally miss important reports (if a report satisfies the generated template).

Custom Auto-Ignore Rules

If the filters described above don’t meet your needs, you can create custom auto-ignore rules based on report field values - those automatically supplied by Logify or custom values you added to reports. Construct a filter criterion visually or enter a filter string manually using intelligent code completion.

Your Feedback Counts

If you have a usage scenario that you’d like to discuss or want to know how Logify can address your 24x7 app monitoring needs, please leave a comment below.

This Month, We’re Boldly Going Where We’ve Never Gone Before

Literally! In this month’s CodeRush release, we’re making Rich Comments available, with support for bold, italics, and other formatting in comments. This release also sees improvements to the Unit Test Runner, Code Formatting, and Selection to Template, plus JavaScript/Typescript developers get new features!

Rich Comments

Want to add emphasis to a Visual Studio comment? Now you can with the Rich Comments feature. The following Markdown-like syntax elements are supported:

• **Bold**
• *Italic*
• _Underline_ (underscores on either side)
• ~Strikethrough~

You can make selected text inside a comment bold by pressing Ctrl+B or choosing the appropriate command from the Embed Selection Action menu

You can turn on Rich Comments on the Editor | All Languages | Rich Comments options page or using the Toggle Rich Comments toolbar button.

Unit Test Runner

With this release, you can now execute a single test case of a parameterized test directly from code. Click a CodeRush test icon and choose the desired option from the Run test, Debug test, or Run test with coverage submenus.

You can also execute a test for a particular descendant of the current class in a similar manner.

Code Formatting

We have enhanced formatting options to allow you specify how you would like to align code blocks. The “Align by” and “Indent” options are available on the Braces option page in Editor | C# | Formatting. On the Wrapping options page you can also align content for Initializers.

Coding Assistance

Selection to Template generates cleaner templates and uses type links, text links, or regular links intelligently depending on element type.

Create Template From Selection dialog options allow you to fine tune a template before committing it, and quickly specify which elements should be wrapped up in text links.

JS and TS Support

Now in Javascript (and Typescript) you can:

• Turn on Structural Highlighting:
  
  
  
• Easily navigate through references with Tab to Next Reference:
  
  
  
• Quickly select and expand/reduce that selection by logical code blocks with Selection Expand/Reduce. Press Ctrl+W to expand selection and Ctrl+Shift+W to reduce it.

Download and Try CodeRush Now!

Download CodeRush from the Visual Studio Marketplace or use the DevExpress Download Manager. And if you're enjoying CodeRush, please leave a review here so the whole world can see.

Coming Up

Next month expect to see more JavaScript features, plus a mind-blowing visual feature for all languages that we think you are going to love.

This post is a follow-up to the previous Tips & Tricks - What You May Have Missed post. In the same series, we also recently published Boosting Application Performance. Many of you commented and asked for more similar content - thank you very much! Here we go.

Import and Export for Appearances

A rather boring task well known to WinForms developers is that of applying changes to element appearances. For example, a button might require changes to its settings for visual states: normal, hovered, pressed, disabled. Easy enough to do if you have one button, and for multiple buttons on the same form you can Ctrl-Click them and change settings simultaneously. But for buttons anywhere else than the current form, the settings need to be transferred in some other way.

Look closely at the Appearance property section in the Properties tool window and you’ll notice an ellipsis button:

Click this button to bring up the Appearance Editor. In this dialog, you can save appearance settings as styles that can be applied to other elements.

Appearance styles are saved as .xml files to the folder C:\Users\Public\Documents\DevExpress \AppearanceTemplates. The Appearance Editor tracks any changes to this folder, so you can save appearance settings in one Visual Studio project and instantly reuse them in another.

Adorner UI Manager

In WPF there is the concept of Adorners and the AdornerLayer, a transparent layer displayed on top of your forms. This layer can be used to draw secondary elements that often overlap controls on the primary layer. For instance, badges are circular or rectangular shapes that notify users about updates or states, like the number of unread emails in your inbox. Of course badges are widely used in web and mobile applications today!

The Adorner UI Manager is a component that implements this concept for your WinForms applications. Here are some examples for badges:

Hints can be attached to any control that supports validation. These elements notify users about the current validation state.

Finally, guides cover the parent container with a semi-transparent layer, leaving a configurable area untouched to highlight it. You can show an optional flyout panel, which makes guides a perfect tool to create interactive tours or to point out specific UI regions to the user.

(Data) Layout Control Secrets

If you have used the Data Layout Control, you probably remember that each data layout item displays a green rectangle in the top right corner at design time. This rectangle shows the name of the bound data field. However, did you know you can also click this label? Try it and you’ll find a dialog that enables quick modifications to the binding settings and the bound field. This is a great feature when you need to modify binding configurations, perhaps due to changes in the data source.

The second “secret” feature applies to the regular Layout Control as well as its data-aware equivalent: to quickly re-arrange layout items, the Layout Tree View tab in the customization dialog supports drag&drop for the elements.

As before, we are very curious about your thoughts and ideas! Did you find the tips helpful? Have you had your own experiences with useful features you didn’t discover right away?

With v18.2, eXpress Persistent Objects™ (XPO) includes additional community-driven feature - FetchOnlyAttribute. Applied to a class property or field, this attribute indicates that you can only read values from a database. XPO will not include these values in INSERT and UPDATE SQL statements.

public class MyClass : XPLiteObject {
    // ...
    [FetchOnly]
    [Persistent("Total")]
    private double total;

    [PersistentAlias("total")]
    public double Total {
        get { return total; }
    }
}​

You can also set the FetchOnly option in the Data Model Designer. In the metadata, the XPMemberInfo.IsFetchOnly property returns True for such members.

Typical scenarios

This attribute is helpful when you need to map XPO class properties to:

1. Computed database columns: when it is inefficient to implement them as read-only using PersistentAliasAttribute.
2. Auto-increment database columns that are not primary keys (for example, rowversion).

How can I test this feature today?

If you are an active Universal subscriber and would like to test this feature prior to the official release, download the DevExpress XAF v18.2 Preview installer. You can also use our https://nuget.devexpress.com/early-access/api Nuget package source.  Check the Include prerelease option when finding and installing the package:

Interesting Support Center tickets

• We improved the consistency between the InMemoryDataStore and other SQL database providers (T648223);
• AddXpoDefaultUnitOfWork and other XPO extension methods for ASP.NET Core DI are not available in XPO for the full .NET Framework. This API is for the .NET Core/Standard 2.0 version only (T657285); 
• We bypassed and reported a Mono bug in which a Xamarin app consumed a WCF XPO-based service (T639333); 
• We discussed dynamic type usage with our recent example: How to implement a OData4 service with XPO (T654401);
• This was originally an XAF-related topic. Two long-time customers jumped in and shared their XPO related experience and performance best practices (T653665);
• A reminder that PersistentAttribute, NonPersistentAttribute and PersistentAliasAttribute are exclusive. Only one can be applied to an XPO member. In addition, there is NO NEED to explicitly mark readonly (getter only) properties with NonPersistentAttribute. Members without a public setter are treated as non-persistent automatically (from a private ticket).

Find more interesting customer questions and product enhancements for your favorite products in the DevExpress Support Center (expand the "Frameworks (XAF & XPO)" group on the right) and What's New documentation (see resolved issues).

Your feedback is needed!

What do you think about this XPO feature and the new "Interesting Support Center tickets" rubric in particular? Please let our team know in the comments.

Love XPO and want to help us promote it? Add the package through Nuget.org instead of DevExpress Nuget!

  Yekaterina K.
  Technical writer
  XPO team

Once upon a time in the distant past, when the grass was greener and the world was young (and all of us were, too!), our designers created sixteen styles for our CheckEdit control. Using the CheckStyle property a developer was able to select one of these styles, but as time moved on so did our aesthetic standards together with those of other Windows application designers. The styles started looking increasingly weird and outdated and we ended up making those enum values invisible …. but they are still around for those brave enough to look for them!

By setting CheckStyle to one of the old values you can create check edits that look like these:

Times are a-changing

Now, I’m not telling this story to scare anybody. I thought it was worth a look back to point out our commitment to legacy functionality - we hate breaking your code! I’m sure there are applications around today that use these old styles, please feel free to comment and let us know if you maintain one of them!

Meanwhile, our designers and developers got their heads together and decided it was high time to introduce some pretty new vector based styles. Here’s what they came up with:

These styles will be available starting with v18.2 (in addition to the old ones, I should add!), and of course they come with all the usual benefits of vector images: they scale up and down without loss of quality, and the can adapt their colors to skins or palettes.

What do you think?

We are publishing this post early in the development cycle for v18.2 because we hope to receive some feedback from you! There are several questions and concerns we have. For a start: do you need additional styles? For instance, the old Style 15 was a light bulb. Do you need a replacement for that? Or do you have a completely different style in mind that we should introduce?

Another perhaps more important question has to do with the indeterminate state that indicates partly checked elements, often hierarchies or groups.

Obviously simple check and radio styles need to support this indeterminate state. But we can’t figure out what this state should look like for, say, a star or a flag. We assume right now that indeterminate states don’t make sense for such styles. Please let us know your thoughts or approaches you have taken before and we will make sure to provide the best possible solutions for your real-world projects!