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.