As Ray said yesterday when talking about the new Rating Control, he and I are going to take it in turns describing the new features and functionality in v15.1 over the next few days. Today, it’s my turn, so welcome to the new features in the ultimate in data analysis controls: the DevExpress VCL Spreadsheet.

Data Export

The first new piece of functionality for the spreadsheet isn’t really about the control itself, but about how it is used with controls in the rest of the VCL Subscription. In essence, we’ve now incorporated it as a principal component of our data export engine. This means that we now have one and only one export functionality for grid or tabular data, and this has allowed us to significantly simplify the data export engine's code and avoid code duplication when implementing new features, both of which are vital to a quickly changing feature set.

In particular, this merging of code provides the following features:

• Ability to export data to CSV files
• Ensuring cell number formats in the exported XLSX file are based on data cell display formats shown in the Grid, Tree List, Pivot Grid, and Vertical Grid controls
• Detail grid Views can now be exported to XLS, XLSX, or TXT files
• The progress of export operations can now be tracked, and aborted if necessary
• Custom encoding formats for strings exported to TXT or CSV files
• Ability to export images to XLS files, including those displayed by cxImageComboBox grid items

One consequence of this work is that the ExpressSpreadSheet Suite is now required for products – especially the grids and treelists – that provide export capabilities and will be automatically installed with them. Since the new spreadsheet was written to support later compilers only, this meant we had to drop support for older compilers.

Once DevExpress VCL v15.1 is released, the ExpressSpreadSheet Suite will be added to the ExpressGridPack and ExpressQuantumPack subscription packs. We will provide a free upgrade to the new SKUs to all customers that own an active subscription to these packs.

New functionality

The v15.1 release includes the following new features for the DevExpress VCL Spreadsheet Control:

• Ability to outline or group data in a worksheet. This gives your users a much better facility for analyzing data using the spreadsheet.
  
  
  
• A new built-in dialog for find and replace operations.
  
  
  
• Support for Excel template files (XLT and XLTX files).
• Ability to export an active worksheet to a TXT, XML, or HTML file.
• Ability to iterate through all generated cell objects.
• Support for the keyboard shortcuts that are available in Excel.

I’m sure you’ll agree these are some welcome new features (especially the data export enhancements). No doubt there are other features you’d like to see with the spreadsheet control, so please do let us know.

We've done our very best to create demos that emphasize the flexibility of our WinForms controls and hopefully give you a clear understanding on how to implement them within your projects. As you already know, many of the demos we ship are module-based and emulate real-world usage scenarios.

To help reduce the amount of time you spend working through our demos and help you master use of DevExpress controls in the shortest possible time, we created a small set of API Code Examples for the v15.1 release cycle. These case-oriented examples demonstrate API usage and illustrate common solutions to everyday tasks. In addition, the examples we've created allow you to review the code, modify it as needed and immediately view your results...

At present time, you can find API Code Examples in three shipping demos: Automatic Form Layout Control, MVVM Best Practices and Desktop UI Manager. Once you open the appropriate demo, you will see the following...

 
...The application is composed of three regions: 

1. Navigation area on the left. Displays all available code snippets categorized into logical groups, and allows you to quickly locate desired examples.
2. Result area on the right. Demonstrates the result of the selected code snippet.
3. Code editor at the bottom. Displays the code and allows you to modify it.
   

When you select a code snippet or modify code, it's automatically compiled and the output displayed within the Results section.

These Code Examples give you the ability to create a temporary Visual Studio project and incorporate the selected code snippet. Click the Run in Visual Studio button on the Ribbon to generate the project and open it inside Visual Studio.

One final note - Going forward, when running any demo as a binary executable file, you can easily open its corresponding C# or Visual Basic solution by using the Open Solution button on the Ribbon bar.

In our last VCL release cycle, we shipped the DevExpress VCL Rich Edit Control - our Microsoft Word inspired word processor - as a community tech preview. With our upcoming release, we'll officially launch our VCL Rich Text Editor and will incorporate the following new features/capabilities: 

• Table support
• Multi-column layout
• Built-in context/popup menu
• Simple and Draft document views
• Horizontal and vertical rulers
• Image sizing
• Support for plain text format files
• OLE drag and drop support

Here are a couple of screenshots demonstrating these new features.

RTF - Horizontal and Vertical Rulers

RTF - Multi Column Layout

In addition, this update will include the following new multi-purpose dialogs:

• Font Editing
• Bullets and Numbering
• Find and Replace
• Insert Table
• Table Properties
• Tabs and Symbols
  

Please note that in the v15.1 beta, the Rich Edit Control only supports RAD Studio XE or later and can only be used in 32-bit apps created with Delphi/C++Builder.

As always, we welcome your feedback and comments - let us know how you are planning to use our VCL Rich Text Editor in your next VCL project.

In blog posts leading up to our launch couple of weeks ago, I described our new XL Export Library – the ultra fast Excel data export engine that generates spreadsheet files by writing them directly to a stream.

If you have used our Document Generation libraries in the past, you may be familiar with the DevExpress Spreadsheet Document Server....A non-visual component library for .NET with complete spreadsheet generation functionality. The Spreadsheet Document Server API allows you to load, create, modify, print, save and export spreadsheet documents and of course perform data analysis and calculate worksheet formulas.

Since the release of v15.1, a number of you have asked for guidance as to which of these 2 products to use within your projects. in this post, I'll try to explain the differences between the two product libraries and hopefully help you choose the right product for your next .NET project. 

I'll start with the key differences between the Spreadsheet Document Server and the new XL Export Library -- the basic algorithms each use for document generation.

Spreadsheet Document Server

The Spreadsheet Document Server's architecture is based on its internal document model which stores all spreadsheet data in memory. This means that when you load a document, the Spreadsheet Document Server reads the file (using the appropriate file format, for example XLSX) and imports data (cell values, formulas, format settings, etc.) to the document model. At this point, you can use the spreadsheet API to modify the model or perform calculations over cell values. Once complete, you can call the SaveDocument or ExportTo* method and export the document model with modified data to the desired file format.

Generating a new document works in much the same way. When you create a new workbook using API methods, the spreadsheet control creates a new document model, generates its content and then exports it to the specified file format. This "universal" approach allows you to use a single library to both read/edit and create new documents....but it can cause significant problems with performance. Generation of very large Excel files will often lead to the high memory consumption and associated time delays.

The graphic below helps illustrate the processes used by the Spreadsheet Document Server and XL Export Library to generate files...

XL Export Library

As you can see in the graphic above, the DevExpress XL Export Library does not use an internal document model and writes data directly to the output stream in consecutive order: row by row, cell by cell. This approach allows it to generate Excel files at very high speeds, with very low memory consumption (because there is no need to put data into an in-memory document model and then export the model's content to the output stream).  

The charts below breakdown the performance advantages when exporting data using the DevExpress XL Export Library. When generating a large XLSX file with 1048576 rows and 20 columns, the XL Export Library is 2.5X faster and uses up to 10 times less memory than the Spreadsheet Document Server.

Your Best Option and Our Recommendation

If performance is your number 1 requirement when generating/exporting data to Excel, and you don't require the capabilities built into the Spreadsheet Document Server, then it's best to use the XL Export Library. It's optimized for performance and allows you to create extremely large spreadsheet files in the most efficient manner possible (important to those of you generating numerous Excel documents on the server side).

I'll wrap this post up with a summary of both products so you can decide what works best for you and your business.

Supported Document Formats

Supported Document Features

*Limited support: enable/disable filtering for the data range without specifying filter criteria.
 ** Available for the entire worksheet data range, not a specific cell range.

To learn more about our new XL Export Library, review our Demo Center examples (see the XL Export API module in the Document Server category) and Code Examples database:

• How to use the XL Export API to generate a list of employees
• How to use the XL Export API to generate a sales report
• How to use the XL Export API to perform a sales analysis
• How to use the XL Export API to generate an invoice

We have added some very useful features to the DevExpress ASP.NET FileManager in v15.1

OneDrive® Inspired Selection

A lot of users do not know how to perform multi selection within MS-Windows list controls by holding down the Shift or Ctrl key while selecting multiple items with the mouse.

In the web-interface of OneDrive®, and also the Windows File Explorer of Windows 8, Microsoft has added a really nice feature; when hovering over an item, a checkbox will appear with all selectable items and when you tick the first one, the checkboxes will stay visible so you can easily select multiple items without the use of the Ctrl or Shift key.

We have put in this same functionality inside our FileManager so you can offer this feature to your end users as well!

FolderItems in Filemanager area

For easier navigation, we have included the sub-folders of the currently selected folder in to the file area. This means you can navigate quicker through the file structure because you don’t need to move your mouse forward and back from the File Area to the Folder Tree. We also included the Parent-folder there as well.

Breadcrumbs with path info for navigation

To make navigation even better, you can now add the breadcrumbs feature containing the current location on top of the File Area. It allows you to jump to any of the parent folders with just a single click, and navigate your way from there.

Uploading files without the Upload panel visible

You can now hide the upload panel from the file manager. In this instance, file upload operations can be initiated by using the upload button, by dropping a file to the control's file area, or by clicking an element specified as a File Upload dialog trigger.

The last feature I'd like to mention is that we have implemented templates for the File Area. I will explain more on this subject in a separate post.

With all these enhancement, our FileManager behaves almost like the native Windows Explorer and it is available for ASP.NET WebForms as well as MVC!

Back in v14.2 of DevExpress VCL we introduced a set of gauges that would help you be more visually expressive with pertinent and important information in your apps and in your dashboards. Well, it should come as no surprise that we’ve expanded on that foundation for v15.1.

New Gauge Styles

Our designer had a spare few hours and went overboard: we’ve added six new gauge styles for v15.1. They are called Clever, Cosmic, Eco, Red, Shining Dark, and Silver Blur, and of those six, my personal favorite would have to be Eco:

The things I really like about this style are the subtle off-white gradient background and the light green needles. A very eco-friendly style, indeed.

Tickmarks on Circular Gauges

Here’s a subtle enhancement for you here: we’ve added the ability to customize the orientation of the tickmark labels. Along with this change we’ve improved the algorithm that positions tickmarks with long labels.

In this case a picture is definitely worth a thousand words, since even we had the hardest problem coming up with one/two-word descriptions of these for the enumeration...

Digital Scale Enhancements

For the digital scales for v15.1, we’ve added a couple of new display modes (8x14 and 5x8 segment matrices) and the ability to adjust the spacing between characters.

This image shows off the 8x14 character matrix.

Other Enhancements

1. You now have the option of animating the indicator or needle.

2. There is a new three-quarter circular gauge.

3. We’ve added the Wide Circular type.

4. Gauges can now have a logarithmic scale. Hey, this take me back: it’s just like a slide rule!

5. You can now define and display your own custom scale captions.

6. There is now a container control for gauges. This not only allows you to group a set of gauges together, but also gives you the opportunity to simultaneously resize them as you resize the container.

Design-time Enhancements

We’ve added a couple of enhancements to help designing with gauges:

• Ability to create nested scales using the scale's on-form context menu
• Ability to copy and resize scales using drag and drop
• On-form selectors for range bars

And with that long list of enhancements, I’m sure you’ll find even better ways for your app or dashboard to display significant information, and allow your users to understand it at a glance.

In this installment of what’s new in DevExpress VCL v15.1, I’m going to look at what’s been enhanced with regard to the user experience.

Map Control

This one sounds simple (and is anything but to code) the map control now supports inertial scrolling. You should know what this is: you’re swiping with the mouse (or finger) to scroll the map and when you release, the map gently comes to a halt.

In addition, users can now scroll the map using the arrow keys on the keyboard.

Layout Control

We’ve added a couple of enhancements for the layout control. (Of course, whenever I mention the layout control, I feel bound to say: use it and save yourself aggravation in laying out dialogs, setting sheets, and what have you. Seriously, it’s great.)

Unified Indicator for Drag-and-Drop Operations

The VCL Layout Control now provides a unified indicator for drag-and-drop operations. This new indicator replaces the earlier styles ("classic" and "hot zone") with more intuitive suggestions on potential drop positions.

Alignment Customization Toolbar

Dropping a layout element in quick customization mode now displays a toolbar that offers options for customizing the element's alignment. The toolbar is automatically hidden once the mouse pointer moves away from the drop position.

Both of these features are shown here:

Data Editors and Controls

• First up, we have added a modern drop-down calendar. This features things like mouse wheel support and animation to give your users a fast and intuitive way to select a date.
  
• Next, our Image Editor now supports animated GIF images. (This would have been handy for this post, let me tell you.)
• You can now align an error icon to the right-edge of an editor that has failed validation. This gives your users a clear indication of where to fix problems in their input.
• The Toggle Switch now allows you to use an image or descriptive text to indicate whether it’s on or off. Here’s some examples:
  
• Finally, we’ve added support for our universal image format to gallery items.

Tomorrow, in our final installment, we’ll look at some other visual design changes to v15.1.

Available now in the DXperience v15.1 release, we've introduced a useful improvement for working with the DevExpress MVC Form Layout extension.

Now it's much easier to configure a nested extension.

Form Layout - MVC

The DevExpress MVC Form Layout extension is great because it helps you to create beautiful forms.

The Problem

The Form Layout extension is a container control where it embeds other controls within it.

The problem is when you want to access one of these nested/embedded controls. To do this, previously, you would have to write some code like this:

settings.Items.Add(i => {
   i.NestedExtensionType = FormLayoutNestedExtensionItemType.ComboBox;var cbSettings = (ComboBoxSettings)itemSettings.NestedExtensionSettings;
   cbSettings.Properties.ValueType = typeof(int);…
});

Solution - Lambda Expression

Now with v15.1, it is simple because you can configure it using a lambda expression:

settings.Items.Add(i => {
  i.NestedExtension().ComboBox(s => {
     s.Properties.ValueType = typeof(int);…
   });
});

The new approach benefits you because you do not need have reference type or a separate variable for settings and properties.

And there's less code to write which makes the code more readable!

Demo sample

Check out the an example of this code here:

MVC Form Layout Demo

What do you think of this code improvement? Drop me a line below, thanks!

A few weeks ago I mentioned that we've added a collection of new icons to our Icon Library - icons we created specifically for our DevAV demo apps. If you've not had the opportunity to review those demo apps, take a moment to run our Demo Center and see some of the user experiences you can create with our WinForms, WPF, ASP.NET and HTML5 UI controls/widgets.

In this post, I wanted to briefly describe what we're now shipping inside the DevExpress Icon Library and hopefully get your feedback and determine the types of icons you'd like us to create going forward. Remember that our Icon Library ships as part of all DevExpress Subscriptions (WinForms, WPF, ASP.NET, MVC, HTML5...etc) AND when you purchase a 12-month DevExpress Subscription, you can incorporate any of these icons within your projects and distribute them royalty-free.

The Icons

First a basic primer for those of you who've not used our Icon Library. As you can see in the image below, we've categorized the icons into groups such as Actions, Alignment, etc.

We've further organized icons by Size and assigned them to individual "Collections" (v15.1 includes a DevAV Collection - see image below).

When you explore these icons, I'm sure you'll find similarities between those inspired by Office 2013 and those we use inside our DevAV app. This leads me to my first question....

Which do you prefer - do you like/use the "flatter" icons or do you prefer the look of more traditional icons inside the "Colored" collection?

Question #1 leads to question #2 - which involves the UX changes inside Windows 10...part of which includes changes to icons. How many of you plan to change the icons used in your apps to replicate those found in Windows 10 (even when shipping solutions that are used inside older versions of Windows)?

And finally, though we cannot add too many "one-off" icons, we can definitely add icons that are widely used simply missing in our current offering. What icons/icon types would you like to see us add in upcoming release cycles?

In our v15.1 release we have another exciting feature implemented for the ASP.NET File Manager. Template support for the File Container!

What is the File Container?

The ASP.NET File Manager control contains a tool bar and two panes; a Folder Container and a File Container as illustrated in the image below:

What does this mean?

With the template support for the items inside the File Container, you can now change how files are represented, and depending on the template, add some custom functionality to the individual items. There are 2 different templates you can implement, one for the Thumbnail view and one for the Details view.

The item which is used to bind the template to is a FileManagerItem instance. At runtime this will be either a FileManagerFile or a FileManagerFolder type, depending on the item being processed.

The FileManagerItem type exposes the following properties available for data binding:

• FullName
• Id
• LastWriteTime
• Length
• Name
• RelativeName
• ThumbnailUrl

The FileManagerFile type, which descends from the FileManagerItem type, exposes all the properties above plus 2 additional ones:

• Extension
• Folder

The FileManagerFolder also descends from the FileManagerItem type and has one additional property:

• Parent

How can I use this feature?

Let’s assume you want to use the DevExpress ASP.NET FileManager for displaying image thumbnails with the possibility to preview the image in a popup:

This behaviour can be build by using the following template:

   1:<ItemTemplate>

   2:<divstyle="<%# GetThumbStyle(Container.DataItem)  %>">

   3:<divstyle="width: 100%; height: 30px;"class="transparent">

   4:<divstyle="float:left">

   5:<dx:ASPxButtonID="ASPxButton1"runat="server"AutoPostBack="False"

   6:UseSubmitBehavior="False"

   7:ImageSpacing="0px"RenderMode="Link"

   8:ClientSideEvents-Click='<%# GetPreviewClick(Container.DataItem) %>'>

   9:<PaddingsPadding="0px"/>

  10:<ImageIconID="actions_show_16x16">

  11:</Image>

  12:</dx:ASPxButton>

  13:</div>

  14:<divstyle="float:left;padding-left:5px;">

  15:<spanclass="item-name">

  16:<%# Path.GetFileNameWithoutExtension((string)Eval("Name")) %><br/>

  17:<%# String.Format("{0:#,##0} kb", Convert.ToDouble(Eval("Length"))/1024)%>

  18:</span>

  19:</div>

  20:</div>

  21:</div>

  22:</ItemTemplate>

For this template to work, I have created some C# helper methods for the data binding. They look like:

   1:protectedstring GetPreviewClick(object item)

   2: {

   3:     FileManagerFile file = item as FileManagerFile;

   4:if (file != null)

   5:     {

   6:return String.Format("function(s, e) {{ previewDlg.PerformWindowCallback(previewDlg.GetWindow(0), '{0}')}}", 

   7:                                               VirtualPathUtility.ToAbsolute(file.FullName));

   8:     }

   9:return"";

  10: }

  11:  

  12:protectedstring GetThumbStyle(object item)

  13: {

  14:     List<string> result = new List<string>();

  15:     FileManagerFile file = item as FileManagerFile;

  16:if (file != null)

  17:     {

  18:          result.Add(String.Format("width: {0}", fm.SettingsFileList.ThumbnailsViewSettings.ThumbnailWidth));

  19:          result.Add(String.Format("height: {0}", fm.SettingsFileList.ThumbnailsViewSettings.ThumbnailHeight));

  20:          result.Add(String.Format("background: url({0}) no-repeat", file.ThumbnailUrl));

  21:          result.Add("padding-top: 70px");

  22:     }

  23:return String.Join(";", result.ToArray());

  24: }

There is a bit more code involved to load and show the ASPxPopupControl and to create custom thumbnail images by utilizing the CustomThumbnail event.

To test this example on your own machine, you can download the demo source code here, and let me know if you have any questions about it.

Last month, I blogged about support for Right-to-Left languages across our WinForms product line. Yes, this was a feature long time in coming and since it's finally here, I wanted to take a moment and show you how you can try our implementation for yourself....

First, the following is a list of DevExpress WinForms Controls with RTL support:

• Charts
• Grid Controls (Grid, TreeList, Pivot Grid, Vertical Grid and Property Grid)
• Data Editors and Multi-Use Controls (Range Control, Rating Control, etc.)
• Ribbon, Menus and Related Controls (BackstageView, AppMenu, еtс.)
• Layout Control and Layout Containers (TabControl, GroupControl, etc.)
• Navigation Controls (Navigation Bar, Tile Control, etc.)
• Application UI Controls (Docking, DocumentManager, etc.)
  

The Windows Mail Client Demo - Updated for v15.1

As part of our v15.1 update, we modified our Windows Mail Client demo (which you can launch via our Demo Center) so that resources are translated at startup. When executing the demo for the first time, you are prompted to specify a locale - English for left to right or one of the following RTL languages:

• Farsi
• Arabic
• Hebrew

As you'll see when you explore the demo, the standard .NET localization mechanism (using resource files) was used to translate the demo. More information on this localization technique can be found on MSDN: Localizing Windows Forms.

DevExpress Localization Web Service

I'd be remiss if I didn't mention the DevExpress Localization Service  - an easy way to create satellite assemblies with localized resources for all DevExpress controls. A number of languages and cultures are available for immediate use and can be easily modified when necessary. Review the following help topic for more information on our Localization Service.

One of the breaking changes we neglected to mention with the release of DevExpress VCL v15.1 yesterday is that the old spreadsheet control, deprecated when we released the new spreadsheet control a year ago, has been completely removed from the install. If you still are using that control, you will have to reinstall v14.2 and continue to use that until you migrate your apps to use the new control.

Our assumption was that since the new control was vastly superior to the old – there’s really no contest – our customers needing a spreadsheet would have spent some time over the past year to migrate to the better one. It seems that we were overly optimistic in that regard, so I apologize on behalf of the team and the company to all those customers who installed v15.1 only to be surprised by the sudden disappearance. Of course, I was positive I had mentioned it in a previous blog post, but alas it appears I was wrong there too (for proof, see the picture of my chair): I can find no mention of our timetable to remove the older control after a year of being deprecated. Again, please accept my apologies. We let you down badly.

My takeout from this is that we have to become a lot better at revealing such large breaking changes well in advance, so that you, our customers, are inconvenienced as little as possible, or at least have enough time to lay down some plans for the inevitable change. Stay tuned to my section here on the DevExpress Community site: I’ll be talking to the team about any such major changes planned for the next 12 months and I will be reporting back in a future blog post.

You may have noticed something peculiar once you’d installed v15.1: no Silverlight controls came as a part of the product and hence were no longer present on your machine. Wait, what?

Back in December 2014, at the time of the v14.2 release, I announced that we were no longer going to update and enhance the Silverlight controls (Silverlight’s future at DevExpress). I’ll quote the relevant summary:

…we made the decision to put our Silverlight controls into maintenance mode as well – in fact, we have already forked the code. We will not be providing any new functionality for our Silverlight controls but will provide maintenance updates to fix any issues as and when necessary. We have already stopped selling DevExpress Silverlight as a separate product (either as a new subscription or as a maintenance subscription) and it is now only available as part of DXperience or Universal.

However, we then made a pretty big faux pas: we removed the controls completely from our products in v15.1, despite our promise to keep it available with DXperience and Universal subscriptions, and despite the fact that we made no announcement of such an action being contemplated, let alone made. The decision was made internally, but the fact that it was a breaking change and an action that required an announcement escaped everyone.

Without further ado, I apologize to our Silverlight customers on behalf of DevExpress for this uncharacteristic oversight. We deeply regret this failure in communication.

So what’s going to happen at DevExpress with regard to Silverlight now?

1. If you have one or more Silverlight apps using our controls that you are maintaining, you will have to remain on v14.2. Possibly this might mean a separate development machine or VM. We do not plan to add the Silverlight suite back to v15.1.
2. We shall continue to provide support and minor updates to our Silverlight controls until next June, when we release v16.1. In fact, let me be a little more precise: we will continue to update DevExpress Silverlight v14.2 with minor releases as and when needed, up to and including 30 June 2016. In essence, if you are an active customer, you will receive support and any updates we publish until that date.
3. After that, that’s it. No more Silverlight. Now, should Microsoft subsequently make some breaking change to Silverlight (which, admittedly, is very unlikely – they’ve just done very minor updates for the last three plus years and the API can be considered as frozen), we shall revisit this policy, perhaps by making a hotfix available to repair whatever issue was brought up by Microsoft’s change. I will not, however, guarantee this.

My recommendation, then? You should strongly consider moving or porting your Silverlight projects to another platform well before the next twelve months are up.

By the way, I shall be making some efforts to ensure that such a situation does not occur again; that you, our customers, are informed well in advance of major changes like this that will affect your development and projects. Your loyalty and satisfaction are of great importance to us.

Last week Mehul and I did a webinar on Entity Framework and DevExpress.ASP.NET.

What is Entity Framework?

Entity Framework is an Object Relational Mapping (ORM) tool, much like our own Xpress Persistent Objects (XPO).

An ORM is a layer between the data storage, and your business logic which allows you to manipulate and query your data store by using C# objects instead of working with SqlConnections, SqlCommands, Datareaders and SQL statements!

It means that you have C# classes which represent all entities (tables) in your database and by decorating classes and properties inside those classes, you can specify things like table names, fieldnames, indexes and relationships in your data.

Under the hood of the ORM tool, the appropriate SQL commands are being created runtime, which also means that if you want to change to a different database backend, if the ORM supports it, you can do that without changing any of your C# code! A good example of this is our own XPO, which supports more than a dozen different database back ends by only changing the connection string.

Why Entity Framework?

With the introduction of MVC, it became clear that the use of an ORM together with the MVC design pattern is an excellent combination since you are already working with models (objects) in MVC, and you are working with objects again to get and store information in the database.

Because of this, Microsoft has been putting some great effort in expanding and optimizing the earlier versions of Entity Framework to what it is today (and will become in the future) and they have even added support for WebForms applications as well by delivering an EntityDataSource to the WebForms Toolbox.

Because it is clear that Entity Framework is the Microsoft way to go, we have already changed over all of our demo applications from Sql Data readers to EntityFramework in v15.1.

This gives you the opportunity to see what is involved in start using an ORM.

What did we cover in the Webinar?

Mehul showed you a couple of different methods on how to start with Entity Framework:

Code first

This means that you will create your data-model directly in C# classes and when you start the application, the ORM will sync the database structure with the C# class hierarchy. This is the strategy Microsoft advices.

Database first

In this scenario, the database is modeled and there will be some synchronization design-time to keep your class hierarchy up to date with the database structure

Model first

This approach will open a designer in Visual Studio which allows you to design your database, where when finished, the C# classes will be created / updated as well as the database structure.

Demonstrated approaches

I have showed you 3 approaches on how to access the data from the Chinook Sample Database, by using the Code First approach. Inside Visual Studio there is a feature which allows you to start a Code First project by existing database. This wizard will analyze the database structure and create the Code First classes for you.

I have used the Chinook Demo Database for this which is freely available on CodePlex at: https://chinookdatabase.codeplex.com/

Microsoft Entity DataSource

The first demo I did was by using the Microsoft Entity Datasource control. It is important to get an updated version from NuGet since the version installed in your toolbox is for Entity Framework v4.5 where the default version as of writing is v6.x.

This version has limited design-time support and you need to type the DB Context class and the desired entity property manually.

The Microsoft Entity Datasource was setup quickly and also supports standard CRUD operations out of the box which I showed with our DevExpress ASP.NET GridView control including standard CRUD operations.

DevExpress EntityServerModeDataSource

Since the sample database does not have mega much data, I am talking about millions of records, the Entity Datasource control performs its task quickly. This will change though when there is a huge database involved and you want to enable the DevExpress ASP.NET GridView’s sorting, grouping, paging, filtering etc.

You can see the impact on our demo site at: http://demos.devexpress.com/ASPxGridViewDemos/DataBinding/LinqDataSourceServerMode.aspx

For such usage, we have delivered the DevExpress EntityServerModeDataSource control. It allows you to perform the required tasks on large datasets much quicker because this control determines what kind of data store is behind the your ORM model and fires the most optimal SQL statements. We have taken some of our XPO expertise and put it in this control.

Also our visual controls like the GridView, DataView and CardView know if they are connected to our EntityServerMode DataSource, and will communicate slightly different with it which results in a dramatic performance increase!

Since this control’s main meaning of live is data reading, you will need to code a number of events manually to allow standard CRUD operations.

Standard ObjectDataSource

While this control was initially released with ASP.NET v2, it is still one of my favorite controls when doing WebForms and data access.

It allows you to totally separate the business logic from the presentation layer and you also have total control on what data to fetch when you enable certain properties on the control.

This control needs a class which implements a number of methods for Selecting and optionally for Updating, Inserting and Deleting.

I have shown you that you can use LINQ queries inside the Select method to fetch results from the datastore. Entity Framework will transform these LINQ queries to SQL statements under the hood.

Conclusion

In case you haven’t checked an ORM like Entity Framework out, we would urge you to take a look at it since it helps you in developing secure and modern applications. We have shown you that it is not MVC proprietary technology and that our DevExpress data controls can take full advantage of it.

You can download the demo project I have been building, as usual, from my GitHub account at: https://github.com/donwibier/DXWebFormsEF.

In the project on GitHub, you will notice that I did implement the CRUD operations, and some additional powerful methods in the ObjectDataSource class for real paged data fetching with LINQ, in combination with Sorting and Filtering.

Let me know what you have already done with Entity Framework or if you’re facing any difficulties!

The new HTML5 / JS Report Document Viewer was introduced in our v15.1 release. This new report viewer is reliant on client-side logic and several enhancements to XAF’s ReportsV2 module were required for its integration.

To use the new DevExpress HTML5 Report Viewer, install our most recent service update (v15.1.5) and set the ReportsAspNetModuleV2.ReportViewerType property to the “HTML5” in the Application Designer:

To preview the appearance and functionality of the report viewer in your web app, simply preview an existing report:

Note:

1. The new report viewer does not use ASP.NET WebForms editors for its report parameters. As such, the WebReportServiceController.CustomizeParameterEditors event is not used.

2.The new report viewer is not used by default and is an option at this point in time. We hope you can test its functionality and provide us with early feedback so we can continue to refine and perfect its use. Once we finalize integration, we will likely enable HTML5 mode by default since it will more nicely suit the improved Web UI (CTP) we are developing for v15.2.

I’m sure that you can’t but helped to have noticed that Microsoft released the latest version of Visual Studio this morning. After completing its fairly lengthy beta, Visual Studio 2015 is now ready for download. There are three versions: Community (which is free for use, but with some licensing and other restrictions), Pro, and Enterprise. There’s lots of new functionality in there, especially dealing with mobile development and the like with UWP (Universal Windows Platform), and of course all of the familiar support for Windows Forms, ASP.NET, and WPF is still there.

Now, I’m sure in being a DevExpress customer, you are at the forefront of technology and raring to go but there’s just one warning niggle at the back of your mind: can I install DevExpress Universal in it? The answer is of course yes, providing that you have downloaded the very latest versions. We released two new versions of DevExpress Universal this morning coinciding with Microsoft’s Visual Studio 2015 launch: v14.2.9 for those customers who are still using the v14.2 series, and v15.1.5 for those who have already upgraded to the v15.1 series. Both of these new versions (or later) will install into Visual Studio 2015 just fine.

For those who are looking for our UWP controls, please be patient just a little while longer. Windows 10 for the desktop is due for launch on Wednesday, July 29 and Microsoft’s sudden withdrawal of the ability to install the betas on new machines has left us a bit in the lurch. Nevertheless, Paul Usher and I will be presenting a webinar this Thursday, 23 July on the new UWP controls, so do take a moment to register to reserve your place.

CodeRush for Roslyn (CRR) v1.0.4 is now available. This free preview version expires on 4 September 2015.

Here’s a list of what’s new in version 1.0.4.

New TextCommands:

• Smart Return, used in the r and lr templates.
• Smart Constructor (C#), used in the cc template.
• ForEach, used in the sw and asm templates.

New Editor Features:

• Smart Cut and Copy
• Show Color 
• Code Cleanup (C# and VB)

New Refactorings and CodeProviders:

• Sort Namespace References
• Remove Unused Member
• Create Event Trigger
• Add Getter
• Add Setter
• Use nameof
• Use Expression Body (C#)

VB Support added for:

• Organize Members
• Debug Visualizer

Unit Test Runner enhancements:

• Performance improvements.
• Ability to exclude selected categories when running all tests.

Code Coverage enhancements:

• Navigate from code to the corresponding Code Coverage tree node.
  
   
  
• Active method highlighting inside the Code Coverage code view window.

Download it, try it out, let us know what you think.

Recently Mehul and I did a webinar about one of our newest demo applications called “DevExpress Documents”.

We talked about the functionality, its architecture and how modular and reusable this demo is constructed.

Why build an Office 365 Clone?

A lot of companies like the Office 365 approach. All documents are stored in one central place and there is no need for specific workstation configuration and deployment. In fact if you want to have a BYOD (Bring Your Own Device) policy, this is the perfect way to go!

Since not all companies are using Office 365, it must come with a caveat.

All documents created and stored on Office 365 are stored in a third-party cloud. This means that you don’t know for sure who has access to them, which is against the security policies of many companies.

With this demo and the webinar, we would like to show you that we have all the building blocks for creating your own document management system which can be easily hosted in-premises, or a local service provider, but with the same ease of use as Office 365.

How to build an Office 365 Clone?

From a UI perspective, besides the login page, this application contains only 3 pages:

Default.aspx

This is the homepage of the application, and serves the File navigation functionality. The main controls used in this page are: ASPxPanel, ASPxMenu, ASPxCallbackPanel and ASPxFileManager.

This page shows how we’re using the responsive and adaptive settings of the ASPxPanel to do some easy positioning like keeping the header always on top in the browser window. We also use the AdaptivitySettings of the filter panel to collapse when the browser window gets smaller than a certain width.

Another cool thing in this demo is the fact that we are switching FileSystemProviders of the ASPxFileManager through a callback depending on the selected filter.

RichTextEdit.aspx

This page serves as editor and viewer of RichText documents like *.doc, *.docx, *.rtf and others. It provides a nice example on how to use an external ASPxRibbon control together with the ASPxRichEdit.

SpreadsheetEdit.aspx

This page serves as an editor and viewer of Spreadsheet documents like *.xls, *.xlsx and others. It contains an ASPxRibbon and an ASPxSpreadsheet control. Like the RichTextEdit.aspx page, it shows how to use an external ASPxRibbon together with an ASPxSpreadsheet control.

The Service Oriented Architecture of DevExpress Documents

If you check out the code behind of the Default.aspx, you will notice that there is not a lot of code in it, except for some initialization. This is because we have chosen a Service Oriented Architecture for this application.

If you check Wikipedia’s definition of the Service Oriented Architecture, you will find:

“A service-oriented architecture (SOA) is an architectural pattern in computer software design in which application components provide services to other components via a communications protocol, typically over a network.”

In the Documents application the services will not communicate over a network, but the first part of the definition certainly applies.

We have defined a number of services which communicate with each other without knowing from each other what is happening under the hood.

An example of this is the DocumentService which handles all document related tasks like locking, editing, creating etc. This service needs data access to fulfill its tasks and therefore, it will communicate with the DataService . The DocumentService is completely unaware of the fact  that the DataService is using Entity Framework to access the database.

An advantage of this architecture is that your application is pretty well structured even when it grows in time.

Another plus of this approach is that if you would like to use another ORM like our own XPress Persistent Objects (XPO), you could create another DataService which facilitates XPO and replace the E.F. DataService with this one.

The Services in the DevExpress Documents application

The services are located in the ~/App_Code folder, and it is definitely worth checking them out. We have defined the following services for the application:

Data service

The Data Service which manage all interaction with the database used for the application.

Document service

The Document Service which will manage the document locking, and keeps track of opened files etc.

File System service

The File System Service will process all file related operations like Opening, Editing, Uploading, Directory creation and modification etc.

Image service

The Image Service will process anything related with image related functionality like the users avatars and thumbnail processing.

User service

The User Service will provide and  manage all user related functionality like validation and activity tracking

These services are all managed by an application object which is the DXApplication instance. One of the reasons for this approach is that it is very structured, but we also need to manage some global (shared) data like locked files etc.
The DXApplication object is an excellent place to store that kind of information.

A final note on the demo app

You can find the source of this demo in the %PUBLIC%\Documents\DevExpress Demos 15.1\Components\ASP.NET\CS\Documents folder where I’d like to mention that this project is a Web-Site project. My guess is that most of you will use Web Application projects, so if you want to use portions of code in your Web Application Project, you will need to change a couple of things before it will work.

If you’re interested in converting this Web-Site project into a Web Application project, let me know. I will put up another blog post with detailed instructions later on how to do that.

Also let me know if you have created your own Office 365 Clone or incorporated this functionality in your own project!

One of the best ways to present data for analytical purposes is through some kind of visualization. DataExplorer could already do this with maps and now it provides another way - Charts. In this initial release, DataExplorer supports 3 types of charts: Column, Line, and Area.

• support for multiple series;
• values of multiple series can be positioned normally (side-by-side for Column chart, for example) or stacked with the ability to show values as a percentage;
• several layouts for value labels;
• ability to show/hide title, axis line, tick marks, labels, and gridlines for each axis;
• automatic orientation of category labels (horizontal, diagonal, vertical) based on the available space;
• legend can be shown on any side of the chart or hidden.

As with List and Map screens a user can select an entity. This is done via tapping on the category label or the value area and allows them to see the related data in the detail or drill-down screen.

As you know, nearly all DevExpress WPF Controls support the display of glyphs/images within their container. For instance, our WPF Grid Control uses glyphs within its column header and the Ribbon Control uses glyphs for its buttons.

I wanted to take a quick moment and point out an important help topic for those of you interested in changing WPF control images based on the following app context/usage scenarios.

• System DPI settings
• App language (UI culture)
• App theme
• Touch-mode availability

DevExpress WPF Controls support automatic image selection based on current app context. We’ve published a detailed help topic that describes all the steps you’ll need to follow to enable this functionality in your next WPF app.