Tweeterfeed

NEW COMMIT by jhorv:new general-purpose list filtering

jhorv — Sun, 20 Sep 2015 15:56:47 +0000

https://github.com/expand/eXpand/commit/17d50d9e871ab3a3b39bdec0852dc49662a3974c

NEW COMMIT by apobekiaris:Sequence generation support for Domain components + EasyTests

apobekiaris — Sun, 20 Sep 2015 15:56:43 +0000

https://github.com/expand/eXpand/commit/be7dc5a6ec9b175ec87622d1433a11a6d13a57c8

NEW COMMIT by apobekiaris:EasyTests for WarnForUnsavedChanges

apobekiaris — Sun, 20 Sep 2015 15:56:41 +0000

https://github.com/expand/eXpand/commit/79b681f5f341eed41bac9f9fe23c6c6c589daa78

BLOG by Dennis Garavsky: How to enable the Conditional Formatting feature of the WinForms GridControl in the XAF GridListEditor and preserve ListView formatting settings between runs?

Dennis Garavsky — Thu, 17 Sep 2015 10:34:00 +0000

In short, this feature allows your end-user to sort or group the data inside the grid AND to visualize selected cells, rows with data bars, icons and predefined or custom appearance schemes. Refer to the following XtraGrid documentation for more information on this feature:

WinForms Controls > Controls and Libraries > Data Grid > Conditional Formatting

GridOptionsMenu.ShowConditionalFormattingItem Property

In general, accomplishing this task in an XAF app consists of several independent parts:

1. Enabling, saving and restoring GridFormatRule objects using the standard XtraGrid as per What is the best way to save and restore information just about Conditional Formatting rules in GridControl without using the RestoreLayoutFromXXX and SaveLayoutToXXX methods?

2. Integrating this solution in the GridListEditor using a ViewController as described in the Access Grid Control Properties help topic.

3. Serializing the grid's formatting rules information, taking into account the fact that it uses a different mechanism for storing settings, which is based on the Application Model. In XAF, it is best to extend the ListView node with a string property that will hold a serialization representation of formatting rules. Refer to the How to: Extend the Application Model article for more details.

This C# source file (include it into YourSolutionName.Module project) illustrates how these parts can be joined together in XAF v15.1.6 (vb.net guys can either use this approach OR convert this code into their language using free tools). It is also possible that this code can be simplified in future versions. I will try to keep this Gist updated as well as the corresponding Support Center thread.

As always, I am looking forward to hearing from you on whether you find this feature helpful for your apps.
Thanks!

UPDATE:
Starting with v15.1.7+, the source code will be 3 lines simpler;-) Refer to this Support Center thread for more details.

BLOG by Robert Anderson: Migrating a large web application from XAF 12.1 to 15.1 - Part 3

Wed, 16 Sep 2015 08:39:00 +0000

This is the third part of a series about migrating a large application from XAF 12.1 to XAF 15.1. In this part I will compare the results of a simple stress test between the versions.

I have described in previous posts how to stress test XAF applications. One of our most basic tests is to simulate 25 users cycling through all the navigation tabs for an hour. I’m happy to report there is a considerable improvement under load in version 15.1.

(Note that we purposefully stress test against a single web application so that we can compare apples with apples. In production we have multiple instances load-balanced.)

Here is an interactive summary of the 15.1 results:

Here is version 15.1. There were zero errors and 382 completed scripts.

By comparison, the same test against DevExpress 12.1 yielded only 258 completions. So 15.1 shows a 48% performance improvement over 12.1.

BLOG by Robert Anderson: Migrating a large web application from XAF 12.1 to 15.1 - Part 2

Tue, 15 Sep 2015 09:37:00 +0000

This is the second part of a series about migrating a large application from XAF 12.1 to XAF 15.1.

In the 13.1 release, DevExpress made a change to the way XAF Validator class is used. It now requires an IObjectSpace parameter corresponding to the object. It is needed to correctly evaluate any rules which are descendants of the RuleSearchObjectProperties. These include:

RuleCombinationOfPropertiesIsUnique
RuleIsReferenced
RuleObjectExists
RuleUniqueValue

A lot of our code has been around for years now and the older parts rely heavily on Session and UnitOfWork instead of IObjectSpace For the most part our application used IObjectSpace only within ViewControllers.

But there were several situations where we need the validator where we don’t have an IObjectSpace. For instance we sometimes need to validate from within method actions (decorated with the ActionAttribute). For performance reasons, we pass criteria to our middleware and it uses a UnitOfWork to run the method on each object. So in this case, there was no IObjectSpace to pass to the XAF Validator.

Here I had a refactoring dilemma to solve. Either I need to rewrite all of the affected rules so that they no longer make use of the IObjectSpace. For instance, I could use RuleFromBoolProperty instead. In our application, this would mean rewriting about 50 rules. Or alternatively, I could go through the entire code base looking for new UnitOfWork() and new Session() and try to use an IObjectSpace instead. When writing code I often find myself having to decide between the ‘quick’ fix and the ‘right’ fix. Here, moving to IObjectSpace throughout is clearly the right fix and although it would take more time to implement, the system will be more in-line with best XAF practices throughout.

Eventually, the refactoring was complete and all unit tests are passing. I was eager to run a multi-user load stress test against the 15.1 version to compare performance under load. I have described in previous posts how to stress test XAF applications. I’ll be sharing the results in the next post.

BLOG by Robert Anderson: Migrating a large web application from XAF 12.1 to 15.1 - Part 1

Mon, 14 Sep 2015 09:01:00 +0000

I am the principal software architect for a treasury application in use by over 100 large multinational corporates. Upgrades are generally met with reluctance in the enterprise world and so we’ve been somewhat stuck on an old version of the expressAppFramework.

Recently I’ve been pushing to move to the newer version and I have spent about three weeks migrating the substantial code base to XAF 15.1 and .NET 4.6.

The steps are:

Run the project converter tool.
Try to compile. Identify the errors which are easily fixable (check with the ‘breaking changes’ documents from DevExpress.)
When in doubt, compare the libraries with a decompiler like .NET Reflector.
Refactor where necessary (ensure you have unit tests for the behaviour you are changing).

On this last point, my whole approach to refactoring has been shaped by Michael C. Feather’s book Working Effectively with Legacy Code. Highly recommended for anyone maintaining complex applications regardless of whether the code is legacy or not…

I was pleasantly surprised that I was very quickly able to get everything to compile and even run. The layout was not correct, but a lot of things worked straight away.

I then had to spend some time restoring the customisations we’d made to the default ASP.NET layout. In XAF 12.1 these were applied directly to default.aspx.cs and dialog.aspx.cs, but in 15.1 these no longer exist. Instead, you can customise layout by providing your own alternate templates. I was expecting this to be much harder, but by following the instructions in the documentation I managed to restore our layout quite easily.

I still had a lot of failing unit tests. One seemingly minor change to XAF validation proved to be a lot of work to fix in our code. Since 13.1, the XAF Validator class now requires an IObjectSpace parameter in the constructor. This was by far the biggest problem to fix and is the subject of the next blog post.

BLOG by Dennis Garavsky: How to reset View customizations made by end-users (UPDATE)

Dennis Garavsky — Wed, 09 Sep 2015 07:38:00 +0000

I invite you to test an updated version of the previous E1897 solution (it is now marked as obsolete), which we are planning to include in v15.2 by default. The new solution supports both WinForms and ASP.NET apps and also works for both the root and nested Views (e.g., the ones embedded into ListPropertyEditor and DetailPropertyEditor):

Testing

To test this new solution in the current v15.1, include this C# source file into YourSolutionName.Module project (vb.net guys can either use this approach OR convert this code into their language using free tools).

Poll question

I also have a question to you: what is the best location for the Reset View Settings command?

1. In a separate Tools sub-menu (one per root form);

2. In the toolbar accompanying each View (may be too noisy);

3. Suggest other locations and demonstrate them with screenshots (e.g., context menu).

I am looking forward to hearing from you.

BLOG by Dennis Garavsky: Getting ready the ConditionalAppearance module infrastructure for custom options of the extended AppearanceAttribute (e.g., tooltip)

Dennis Garavsky — Tue, 25 Aug 2015 10:52:00 +0000

First of all, this piece of information is quite advanced, so be sure you are well-aware of the module's basic functions and main extensibility and customization points, at least through AppearanceController. If not, check out the related online documentation before reading further.

Customer scenario

Would it be possible to add in the conditional appearance module the possibility to show a tooltip in the cell in listView when the

condition is satisfied? (you get different color based on criteria and when you move to the cell a tooltip is shown telling you why the color is different ), example:

[C#]

[Appearance("CategoryColoredInListView", AppearanceItemType = "ViewItem", TargetItems = "Category", Criteria = "Category = 'Seafood'", Context = "ListView",FontColor = "Blue", Priority = 1, ToolTip="the tooltiptext!!!!")]

Alternative solution considerations

If there were no ready built-in module in XAF, you could solve this by using the pure means available for the underlying grid control for a target platform. For instance, in WinForms, you could employ the ToolTipController API, while for ASP.NET WebForms you could handle the ASPxGridView events to programmatically assign a tooltip text to required data cells. Apparently, making these custom-tailored control-based solutions universal would require effort without XAF, and XAF users could even see this work as a duplication of the perfect existent infrastructure ConditionalAppearance provides. So, let's describe how to do things the XAF way!

XAF way

Let me repost the answer my colleague provided in the original SC ticket and then elaborate more on the technical aspects of this solution:

We designed the Conditional Appearance module to control various properties of controls and provided implementation for the most useful properties of DevExpress ASP.NET and WinForms controls: Enabled, Visible, BackColor, FontColor and FontStyle. However, there are other controls and properties that can be managed using the Conditional Appearance module capabilities.

We reviewed our implementation and made a few changes in our code to support new properties, so you can request a hotfix right now, and we will publish it for you. This change will be included into the next public release/update for the 14.2 release.

The attached project demonstrates how to introduce an additional string value to the 'AppearanceAttribute' class and apply this string to the ASPxGridView cell as a tooltip in accordance with the Conditional Appearance rules. Note that other controls and properties may require other code to show a specified string as a tooltip. Please review the corresponding documentation for a necessary control for more details on how to implement this scenario.

T248959.ZIP

Technical details

Solution26.Module:

AppearanceWithToolTipAttribute.cs - contains a definition of an AppearanceAttribute descendant with a custom ToolTip property (its sample use is shown in the Class1.cs file) as well as several required service classes to propagate this new option through the Application Model and the whole ConditionalAppearance module infrastructure. For instance, the AppearanceItemToolTip class is an AppearanceItemBase descendant that serves the same role as AppearanceItemEnabled, AppearanceItemFontColor and other built-in implementations (here it solely holds a tooltip value).

The IModelAppearanceWithToolTipRule interface and its domain logic define a custom Application Model element that extends the built-in IModelAppearanceRule with the ToolTip property (see the Module.cs file for the registration code).

Finally, the ToolTipAppearanceRule class is a descendant of the service AppearanceRule class with a single overridden method that instantiates AppearanceItemToolTip objects for IModelAppearanceWithToolTipRule nodes defined by a user in the Application Model.

Solution26.Module.Web:

AppearanceGridViewToolTipController.cs - contains a ViewController that handles the CustomCreateAppearanceRule and ApperanceApplied events of the built-in AppearanceController for connecting rule metadata information with the underlying control customizations. In other words, the information from the AppearanceItemToolTip entity is propagated to the built-in TableCellAppearanceAdapter object, which represents a precise implementation of the IAppearanceFormat interface (there are various implementations for different UI entities in XAF). Or, simply, a link between the underlying UI control and its TableCell object to which various appearance options (font, color, tooltip) can be applied.

BLOG by Dennis Garavsky: A more straightforward and convenient way to query data using LINQ with ObjectSpace

Dennis Garavsky — Mon, 24 Aug 2015 15:10:00 +0000

First of all, it is important to note that the capability to query data using LINQ has been available for a long time in the current version of XAF (or better said, in the underlying Entity Framework and XPO ORM libraries). So, this improvement in v15.2 is all about improving developer usability by exposing a helper method for the IObjectSpace interface representing one of the main XAF entities (learn more...).

As noted in the corresponding SC ticket (from here you can also learn on the current solution):

The IObjectSpace interface now declares the following method:

[C#]IQueryable<T> GetObjectsQuery<T>(Boolean inTransaction = false);

This method is implemented in the XPObjectSpace, EFObjectSpace and NonPersistentObjectSpace classes.

The inTransaction parameter has effect in XPO only and enables the mode in which querying a data store for objects includes all in-memory changes into query results.

In the NonPersistentObjectSpace, the GetObjectsQuery method casts the collection of objects created in the ObjectsGetting event to IQueryable and returns the result.

For XPObjectSpace, this method just returns a new XPQuery<T> from the underlying Session, while for the EFObjectSpace, the GetObjectsQuery method returns a new instance of ObjectQuery<T> with the help of the associated DbContext.

Here are a few usage examples from our unit tests (using the method-based query syntax):
EF:
IQueryable<Product> objectsQuery = objectSpaceB.GetObjectsQuery<Product>().Where(p => (p.Supplier.ID == supplier_A.ID));
Assert.AreEqual(5, objectsQuery.Count());
Assert.AreEqual(3, objectsQuery.Where(p => (p.Name == "A")).Count());
Assert.AreEqual(2, objectsQuery.Where(p => (p.Name == "B")).Count());

XPO:
IQueryable<TestObject> query = objectSpaceB.GetObjectsQuery<TestObject>();
Assert.AreEqual(5, query.Count());
Assert.AreEqual(3, query.Where(t => t.StringProperty == "A").Count());
Assert.AreEqual(2, query.Where(t => t.StringProperty == "B").Count());

I hope you will appreciate this minor improvement and it will save you from polluting your code by the casts to the XPObjectSpace/EFObjectSpace types to access the underlying ORM data context LINQ features.

BLOG by Dennis (DevExpress Support)XAF: A preview of the HTML5/JS Report Document Viewer integration in Web UI (Shipping in v15.1.5)

Mon, 20 Jul 2015 11:20:00 +0000

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.

BLOG by Dennis (DevExpress Support)XAF: Enhancements to App UI Management Settings in the Database (Shipping in v15.1)

Thu, 04 Jun 2015 19:00:00 +0000

This feature was first demonstrated in our v14.2 release and based on your feedback, was one of the most popular additions to the eXpressApp Framework. For this release, we have made it even more powerful by implementing the following features:

The latest design-time changes made by developers to the Model.XAFML file representing shared model settings will be automatically re-read and considered by the application while debugging in Visual Studio. Technically, we have integrated a code solution from this Support Center thread under the #DEBUG directive via the XAF solution wizard so that all newly created apps have this default behavior. If you need this feature in your existing app, implement the current solution from the aforementioned thread.
As for updating shared model settings in production environments, you can now import the new settings from the application UI via the Import Shared Model Difference Action of ModelDifferenceViewController, which is available in WinForms apps only. Technically, this command silently loads the contents of the Model.xafml file to the Shared Model Difference object stored in the database.

Initially, there was no easy way to have application UI settings for WinForms and WebForms apps stored in the database separately. With the v15.1 release, the ModelDifferenceDbStore class constructor was extended to accept the string ContextId parameter. This allows you to pass “Win”, “Web” and other custom constants, like “Tablet”, for different applications and configure their user settings independently. To save you time, the default prefixes are automatically added for new applications by the XAF solution wizard. Existing applications can be modified as follows:

private void Application_CreateCustomUserModelDifferenceStore(Object sender, CreateCustomModelDifferenceStoreEventArgs e) {
e.Store = new ModelDifferenceDbStore((XafApplication)sender, typeof(ModelDifference), false, "Web");
e.Handled = true;
}

The code of the Create Model Differences Action of ModelDifferenceViewController was modified to take into account all the available ContextId values and create Model Difference objects in the database for each available application user.

Previously, the Copy Model Difference Action opened a dialog to copy model settings for the selected user to another user by fully overriding them. With our current release, you can choose to either Overwrite target model differences or Merge the source and the target using the Copy Behavior option:

Technically, this is a smarter version of the Copy command that does not replace everything, but rather combines both differences together. At this stage, there are no special dialogs to merge only certain Application Model setting nodes as is done in the Merge Model Tool.

BLOG by Dennis (DevExpress Support)XAF: Enhancements to existing modules, Entity Framework and performance (Coming soon in v15.1)

Thu, 28 May 2015 18:14:00 +0000

Notifications Module - Officially Shipping

The eXpressApp Framework's Notifications Module (which first shipped as a CTP in v14.2), will officially ship in v15.1 and can now be used in production environments. This update includes a refactored API to simplify its use, addition of new features, improved stability and performance.

We appreciate all the great feedback you provided to us as it helped us cover even more use-cases with this module.

Here are a few of the new features we've included in the Notification Module:

Ability to open an editable DetailView for the notification record.
Unobtrusive notifications when only the number of items changes in the status bar.
Ability to display all or only postponed items.
Improved processing performance.

Workflow Module - Entity Framework Support

The Workflow Module integrates Windows Workflow Foundation (WF) 4.0/4.5 support into XAF. WF is a workflow management framework designed to assist you in creating more manageable, workflow-enabled applications. By leveraging WF functionality, the Workflow Module allows you to automated long-running business processes within your XAF application - where the intermediate steps are hours, days or weeks apart. The module allows users to modify the automated processes without writing any code or visualizing complex business processes.

With v15.1, you can now integrate our Workflow Module when using Microsoft ADO.NET Entity Framework. To achieve this, we have implemented EF-compatible versions of workflow entities like EFWorkflowDefinition, EFWorkflowInstance, EFTrackingRecord, EFStartWorkflowRequest, etc., and performed other required R&D and testing work.

Additional Enhancements to XAF's Web and WinForms UI, its Core and Performance

The ASPxDocumentViewer control is now used for report previews in ASP.NET applications (we've deprecated the old Report Viewer control.) By using this new report viewer, cascading parameters and Drill-Down report types are now supported within XAF ASP.NET applications:

Delayed data loading for detail forms has been implemented forWinForms apps. It’s best to demonstrate this with a short video (note that an artifical pause was intentionally added to emulate loading a large amounts of data). You can manually enable this mode via the DelayedDetailViewDataLoading property of the XafApplication class, which can be set either in code or via the Application Designer. Technically in this mode, the DetailView form is displayed nearly instantly, without any data in controls and then data asynchronously retrieved from the database and the controls (e.g., editors display actual data values and the related Actions are updated) are updated accordingly. While this does not really speed things up, it helps to achieve a better UX and perception, as a user receives instant feedback, which may be useful for very complex forms. Take special note that when you enable this mode, the DetailView.CurrentObject will not be immediately available when ViewControllers are activated. Your code should take this situation into account. Our own code already handles this mode well – you can see that the standard Delete Action is activated after data loading is complete.

WinForms apps can now place Actions within the status bar. The easiest way to do this is to set the Category property of your Action to “Notifications”. For instance, this way the Show Notifications Action (the one that displays a “bell”) from the Notifications module is implemented. In addition, review the attached picture and see how I moved (without writing any code and by just using the Model Editor and its ActionDesign | ActionToContainerMapping node) the other built-in Refresh command into the status bar. Alternatively, you can make a custom template as per this document and manage placement via the XAF BarManager or RibbonControl designers.

Another WinForms enhancement is for developers using advanced ribbon menus within their applications. It's now possible to place multiple Action Containers within a single RibbonPageGroup (watch video) and also make it possible to separately configure different menu modes for SingleChoiceActions placed within the same group. Only the required part of Actions from a single RibbonPageGroup can be mapped to the Application Menu or Status Bar. This capability is best illustrated with a short video. You can see a "View" RibbonPageGroup that originally contained two Action Containers: "View" and "Reports". We then add only the "View" container into the Application Menu. There will be more documentation on making these customizations once v15.1 is out.

We now include a much simpler solution to open a non-persistent object's List View directly from the navigation bar or from custom Actions. The idea is to declare a non-persistent class and decorate it with the DomainComponent and DefaultClassOptions attributes...Then, handle the NonPersistentObjectSpace.ObjectsGetting event and populate the e.Objects collection as required. That's it. Subscribing to this event can typically be done on the ObjectSpaceCreated or ListViewCreated events of the XafApplication class. Internally, the new NonPersistentObjectSpace entity is automatically provided for such non-persistent ListView through NonPersistentObjectSpaceProvider, which is registered among other ORM providers at startup. See a complete example in this Support Center ticket. Take special note that in WinForms you can create non-persistent objects with the New Action and navigate to the DetailView of a non-persistent record, make changes and they will automatically be reflected in the source ListView (all changes will obviously disappear after reopening the ListView). See this short video for more info.

We've reduced the number of web browser requests to the server for Web apps in the following scenarios: a) when opening a page for the first time; b) when refreshing a browser page via F5; c) when displaying a popup window. In addition, with several optimizations to the underlying types info system, we've cut startup time by~10-15%.

Hopefully you'll find all of these enhancements useful. Tell us what you think - we want to hear from all our XAF users!

BLOG by Dennis (DevExpress Support)XAF: New Web UI Theme, Templates and Optimizations for Desktop and Tablet Browsers (Coming soon in v15.1)

Tue, 26 May 2015 18:19:00 +0000

So what do we have planned for XAF in this release? It all starts with the web...

As you can tell from the images below, we decided to change direction from our previous Web UI prototypes based on the Moderno theme (check here) and instead we've started implementing a brand new concept created by our UI designers. The result is an overhauled ASP.NET WebForms theme for XAF Web apps (it’s not available for our ASP.NET controls at present time), new webpage templates and associated optimizations for touch screen devices. All of this should make accessing XAF web sites from both desktop and tablet browsers more intuitive for your end-users (I hope to talk about smartphones separately later this year).

In the upcoming release we wanted to share a preview (CTP) of our work to date so you can understand where we are heading. We hope to finalize all that we have planned with regard to look & feel, general UX, application flow and behavior by 15.2. It is likely that there will be more updates on this new web theme in the coming months.

At this time, we want to get your feedback and hear your thoughts. We want to work with you to create the best possible solution so you can build apps that address the widest possible use-cases going forward.

Here is a short video that demonstrates our responsive layout in action...so you can get a better sense of how an XAF web application adapts itself as browser width or orientation changes.

Our XCRM demo will use the new style by default. To learn more on how to enable this theme in your existing apps and see how it works for yourself and provide feedback/report issues, refer to this knowledge base article.

BLOG by Dennis (DevExpress Support)XAF: Enhancements to Existing Features & Performance Tuning (Coming soon in v14.2)

Thu, 20 Nov 2014 11:00:00 +0000

Grid Designer for List View

In XAF v14.2, responding to customer feedback, we introduce a new easy-to-use way to configure List View columns at design time. Model Editor now includes a designer that imitates the grid filled with sample data. When the ListView | Columns node is focused, the property list to the right is replaced with a design surface. This allows you to see how the grid will be displayed at runtime. Take special note that while the WinForms Data Grid control is displayed at design time. However, the customizations are correctly applied for both WinForms and ASP.NET applications.

The designer provides the same configuration capabilities that are available in XAF WinForms applications at runtime. You can:

resize columns;
drag and drop column headers to re-arrange columns;
hide a column by dragging it outside the grid;
show hidden columns using Column Chooser;
apply sorting, grouping and filtering;
display summaries (when you enable the IsFooterVisible property).

Data-Specific Column Types for ASPxGridView

Starting from version 14.2, opening, paging, grouping, sorting and filtering of lists displayed through the ASPxGridView control in XAF works noticeably faster. We extended our code to use data-specific column types whenever possible. The use of data-specific columns for simple types like System.String, System.DateTime, System.Boolean, etc. allows reducing the request processing time on the server side, reducing rendering time in the browser and reducing traffic due to the simplified page structure.

Take a look at the video that demonstrates an XAF Web application displaying a grid with 50 objects and 13 columns within Internet Explorer 11 on the test machine with Intel(R) Core(TM) i7-3770 CPU 3.40GHz, 16384MB RAM, Windows 8 Enterprise 64-bit and IIS 7

These are the results of our measurements of this application:

By default, table data in ListView of XAF Web applications is displayed using the ASPxGridView control. Previously, cell values were displayed using the ITemplate templates specified via the GridViewDataColumn.DataItemTemplate property for data cells and GridViewDataColumn.EditItemTemplate for edit cells. With this approach, we have full control of the data representation in grid cells and can use the same editors to display properties in List Views and Detail Views. However, the approach has certain drawbacks, like overall complexity, increased markup generation and rendering time, and difficulties in configuration and customization.

To overcome these drawbacks, in version 14.2, we extended our code to use data-specific column types whenever possible. Even though the DataItemTemplate approach is still used when there is no appropriate data-specific column information, the performance impact is significant in many configurations. In the inline edit mode, we still the rich editing capabilities of EditItemTemplate (which are also used in the Detail Views).

You can easily adjust the default columns settings or create new custom columns using events the following ASPxGridListEditor class events: CustomizeGridViewDataColumn, CreateCustomDataItemTemplate, CreateCustomEditItemTemplate, CreateCustomGridViewDataColumn.

Please note the following limitations of the new mode.

You cannot navigate to a referenced object by clicking a cell that displays a reference property.
The "N/A" text is not displayed for null reference values.

If you want to revert back to the old mode for any reason, set the static ASPxGridListEditor.UseASPxGridViewDataSpecificColumns property to false in the Global.asax.cs (Global.asax.vb) file:

protected void Application_Start(Object sender, EventArgs e) {
    ASPxGridListEditor.UseASPxGridViewDataSpecificColumns = false;
    // ... 
}

New Image Property Editor

As a part of the effort to speed up XAF applications, we will introduced support of byte array image storage for Image Property Editors (in both WinForms and ASP.NET). This allows us to decrease web server memory consumption, because the byte array can contain an image in a compressed format and the server does not have to unpack it. Additionally, you can enable the delayed (or lazy) loading of images to further decrease memory usage. Practically, this means that you can display large list views with lots of images and experience no performance issues.

Another nice thing about the new editor is that we made it possible to navigate to a detail form when clicking on the image cell in the ListView, which was not present previously.

To use a byte array persistent property as an image storage, simply decorate it with the ImageEditor attribute:

[ImageEditor]
public Byte[] Photo { get; set; }

If you want to implement lazy loading for such properties, check out the examples for Entity Framework and XPO when v14.2 is out.

Notice that the previous approach with the System.Drawing.Image type property is still supported, but we recommend that you migrate to the byte array storage to get the performance benefits described above.

Solution Wizard Improvements

Now you can run the Solution Wizard from an existing solution to add extra XAF projects (Application Server,Workflow Server, etc.):

Additionally the wizard is now included in the DevExpress Template Gallery. Our future plans regarding the wizard include better organization of the XAF Item Templates (ViewController, Frame Templates, etc.) and capability to create test data and configuration for all the XAF extra modules.

Data View Mode for List View

The Data View mode released as a beta in v14.1 is now fully released in 14.2. In this mode, a lightweight read-only list of data records (a data view) is retrieved from a database in a single request without loading complete business objects. This list can be queried much more quickly than a real objects collection. You can now use this feature in your production environment to improve performance for use-case scenarios involving large volumes of data.

Miscellaneous Improvements

· Specifying a client's logo is now completely simple. You can set the required image using the Logo property of the Application node in the Model Editor. This works both for WinForms and ASP.NET applications, and you no longer need to dig into the details of different approaches for WinForms and ASP.NET in most cases - the framework handles this all for you.

· Newly created XAF Web apps will now display detail collections in DetailView, which is in 'edit' mode by default (don't worry as this does not affect existing apps). This saves your extra clicks on switching between the "view" and 'edit' modes.

· The ExpandObjectMembers attribute now allows expanding a specified single member of a complex type property. This adds more control over layout generation in both ListView and DetailView as previously you could only expand all or nothing.

· An Entity Framework-based version of our popular XCRM demo was created in this release. While accomplishing this task, we strengthened Entity Framework support in XAF and improved its stability. Check it out at %Public%\Documents\DevExpress Demos 14.2\Components\eXpressApp Framework\XCRM\CS\ once you get your hands at 14.2!

· DevExpress XPO (an alternative to Microsoft Entity Framework for data access in XAF) now supports the latest ADO.NET connector libraries for Sybase (Sybase.AdoNet2.AseClient.dll and Sybase.AdoNet4.AseClient.dll), which are completely managed and include the latest improvements for working with this database engine.

As always, we welcome your comments and feedback. Let us know what you think.

BLOG by Dennis (DevExpress Support)XAF: Brand New Module & Features for both Windows and the Web (Coming soon in v14.2)

Tue, 18 Nov 2014 01:00:00 +0000

End-User Report Designer for ASP.NET

With this release, the Reports V2 module supports the ASP.NET Report Designer out-of-the-box. End-users can create and modify reports directly in a browser!

Check it out! We have already incorporated this functionality in all of our demos that include reports. (e.g., in MainDemo or FeatureCenter).

Note that you do have to change your code to enable the designer in an existing XAF app. If you have an application with the Reports V2 module included, simply upgrade it to v14.2 using the Project Converter tool.

After the upgrade, you will see that the New Action is now available in the Reports View. To design an existing report created at runtime, select it and click Show Report Designer.

The ASPxReportDesigner control is displayed in a popup by default. You can change this behavior using the ReportsAspNetModuleV2.DesignAndPreviewDisplayMode property. If you change the mode from Popup to DetailView in the Application Designer, the designer will be displayed in the main window (screenshot).

New Notifications Module for WinForms and ASP.NET

With this release, we've added a new Notifications module (CTP) allowing you to display reminders for scheduler appointments or any custom objects, e.g. tasks. The Scheduler module itself was improved to provide the corresponding UI for configuring reminders and visualizing them in the calendar. Basically, when creating a scheduler event you can create reminders like in Outlook:

and then an application will display a popup window before an event starts:

The Notifications module is a separate module which does not necessarily have to be bound to the Scheduler module: it can display notifications that come from anywhere. In the latter case your goal as a developer is to just feed the notifications service with notification items and the service will process them as required. For now, please keep in mind that this will ship as a preview. We are looking forward to your feedback so we can continue to improve the module to meet your specific requirements.

User Settings Stored in the Application Database

Starting with v14.2 all application settings and user preferences (so-called model differences) can be stored and managed directly in the application database for both WinForms and ASP.NET applications. This feature enables your customers to “roam” between machines and still have access to the appropriate settings:

Previously, these settings were stored in the file system (for WinForms) and in the browser cookies (for ASP.NET) by default. There was also a mechanism for preserving this stuff in any custom data store.

This functionality is implemented in the system module and it is activated automatically when you enable the Security System in the Solution Wizard or in code. This new settings storage is enabled by default in all newly created WinForms apps. You can enable the same in existing or Web applications by writing a few lines of code.

Bands Support in Grid List Editors for WinForms and ASP.NET

You can now enable bands in grid controls for both WinForms and ASP.NET applications:

The band layout can be configured either at runtime via the grid control interface or at design time via the Model Editor under the Views | ListView | BandsLayout node (even in the platform-agnostic module!):

While working on this feature, we have refactored our Grid List Editors (XAF wrappers around the GridControl and ASPxGridView components) so that now it would be much easier for you to enable support for other view types (card view, layout view, etc.) by inheriting from our classes.

New Ribbon Templates for WinForms

We introduced the new Ribbon templates for Main and Detail forms of a WinForms application. Now you can easily customize the placement of your UI commands via the familiar interface of the RibbonControl wizard you often see in traditional WinForms development:

These new templates are also registered for the 'Add New Item...' dialog in Visual Studio so you can add them into your project and customize according to your business needs:

The improved templates are also used in newly created XAF projects by default.

Previously, we provided a single universal version of our WinForms templates for both classic and ribbon menus. While this universality had some great advantages for us at runtime, it cause issues whenever customization was needed. Yes, it was possible to customize everything at runtime, but it was much less convenient for developers.

So, now, say, placing any standard or custom Action command into a custom ribbon group is no longer a problem at design time. Check out this short video for more details.

As always, we welcome your comments and feedback. Let us know what you think.

P.S.

This is of course not all that our team has prepared for the upcoming 14.2 release. In my next large post I will cover a bunch of enhancements to existing features & performance tuning for ASP.NET.

BLOG by Dennis (DevExpress Support)Security System Usability Improvements (Coming soon in v14.1)

Mon, 02 Jun 2014 06:40:00 +0000

With the new CheckedListBoxPropertyEditor editor, application administrators can now easily assign member-level permissions:

Technically, we have provided two PropertyEditor implementations (one for Windows and one for Web), which can display values via a checked list box control in the UI and store the resultant choice in a string property of a business object. For now, these editors are used only in the security module, but we can come with a more generic solution in the future if there is a good demand from our customers.

With the new XAF Solution Wizard, you can easily create client-server applications. The wizard automatically creates a project for the application server and makes necessary changes in the client application’s code.

BLOG by Dennis (DevExpress Support)XAF Solution Wizard for easier getting started (Coming soon in v14.1)

Mon, 26 May 2014 04:30:00 +0000

XAF now ships with the wizard which allows you to quickly create a new application in a few simple steps. All you need to do is choose a target platform (desktop, web or both), data model type (Entity Framework Code First, Entity Framework Model First or XPO), user authentication type, and finally select extra modules to include in your application. The wizard will automatically generate a solution according to the specified settings.

To learn more, either watch the video or check the screenshots below.

To start the wizard, choose DevExpress v14.1 XAF Solution Wizard in the New Project dialog.

Step 1 – Choose Target Platforms

In this step, you can choose Windows, Web or both.

Step 2 – Choose ORM

In this step, you can choose your data model type – Entity Framework Code First, Entity Framework Model First, or eXpress Persistent Objects (XPO).

Step 3 – Choose Security

In this step you can enable the Security System and choose the authentication type.

If you choose XPO in the previous step, you can also enable Integrated Mode or setup the Middle Tier Application Server.

Step 4 – Choose Extra Modules

At this last step, you can choose the required extra XAF modules to enrich your application with an additional functionality:

Now you can click Finish and and see the result. The following image demonstrates that the wizard automatically generates the solution code and even populates the data model with entities required by the Security System and chosen extra modules.

BLOG by Dennis (DevExpress Support)New DataView mode for ListView (Coming soon in v14.1)

Thu, 22 May 2014 03:00:00 +0000

The UseServerMode Boolean property of the Options and ListView nodes is now replaced by the DataAccessMode property of the CollectionSourceDataAccessMode enumeration type. This enumeration contains the Client, Server and DataView values.

The Client value is equivalent to the UseServerMode set to false in previous versions. The Server value is equivalent to the UseServerMode set to true in previous versions.

DataView is a new mode. ListView in DataView mode retrieves XPView or EFDataView lightweight read-only lists of data records without loading complete persistent objects via XPCollection/EFCollection.

Check out the screenshot from the Model Editor for more details:

As you might remember, this new Data View data source was first introduced in the ReportsV2 module, which provides the ViewDataSource component. Originally it was supported for XPO and then for Entity Framework (learn more...).

This functionality will be out as Beta in 14.1, because not all standard scenarios we planned for are covered and tested at this time. For instance, in the first version the DataView mode will work for Grid List Editors only. The rest of the built-in ListEditors (like TreeList , PivotGrid, Chart, Scheduler, etc.) will use Client mode by default, even if the DataView mode is specified in the model settings. Support for these List Editors is planned for the future.

Also, data for non-persistent and reference properties will not be shown in ListView operating in DataView mode by default. To make reference properties work in WinForms, it is required to add a custom model column pointing to a nested property, e.g., Department.Title (this step is not required on the Web).

To enable this functionality on the Web, you currently need to modify the Global.asax.cs file as shown below:

protected void Application_Start(Object sender, EventArgs e) {
ASPxGridListEditor.OldColumnsCreationMode = false;
}

We look forward to hearing your feedback on this new mode since Grid List Editors are used in more than 80% of list screens of a typical LOB application.

Yes, the ConditionalAppearance functionality is supported when this new mode is enabled in ListViews:-)

BLOG by Dennis (DevExpress Support)Business Class Library for Entity Framework (Coming soon in v14.1)

Mon, 19 May 2014 12:10:00 +0000

The new DevExpress.Persistent.BaseImpl.EF.v14.1.dll library contains ready-to-use Code-First entities. These include general-purpose entities (like Person, Task, Address, etc.), and entities that are specially designed to be used with XAF extra modules and security system (Event, FileData, User, Role, etc). This addition makes it easier for an XAF developer to get started building applications using Entity Framework for data access.

UI customizations (i.e. Application Model differences) for these entities are also available in the Business Class Library Customization Module.

I think that even non-XAF customers can benefit from these ready-to-use EF data models: they can be used as a guide or reference when customers provide their own implementations.