eXpress App Framework Team
  • XAF - Startup Performance, Application Model and Non-Persistent Objects Enhancements (Coming soon in v16.1)

    In my opinion, XAF's Application Model (defined as a set of application settings or UI skeleton) is the second most important XAF feature (first being automatic database and CRUD forms generation based on your ORM data model).

    Because of its importance, we consistently strive to improve the Application Model and in our upcoming release, we focused our energies on improving startup application performance and general usability for XAF developers.

    Application Model Caching

    With v16.1, you can speed up WinForms application startup using the EnableModelCache property. When set to true, Application Model content is cached to a file when the application is first launched and recovered on subsequent runs. This property works in a production environment when the debugger is not attached (see Debugger.IsAttached). By default, EnableModelCache is set to false. To change this property value, add the following code to the Program.cs (Program.vb) file, before the Setup method is called: winApplication.EnableModelCache = true;

    As a result of these settings, Nodes Generators and Generator Updaters will be executed and the Model.Cache.xafml cache file will be created only when the application is started for the first time. Note that initial startup can take more time than normal, however, the time taken by subsequent startups will be reduced, because the Application Model content will be recovered from the cache. The cache is recreated when application module version is incremented. 

    By default, the Model.Cache.xafml file is located in the application folder. You can change its path using one of the following methods:
    1. override the GetModelCacheFileLocationPath method in XafApplication descendant;
    2. use the ModelCacheLocation key in the configuration file (App.config).

    The Model.Cache.xafml file name is specified by the ModelStoreBase.ModelCacheDefaultName constant. If your application is localized, separate cache files are created for each language (e.g. Model.Cache_de.xafml).


    Frequently Asked Questions

    Q: How is this different from the existing ModelAssembly.dll-based cache?
    A: Unlike the existing ModelAssembly file-based cache (which is technically an assembly providing Application Model object implementation based on the IModelXXX interfaces), the new model cache file contains the entire model structure in XAFML format.

    Q: Is this cached file an equivalent of merging of the platform agnostic model and WinForms/ASP.NET models?  Does this include user modifications?
    A: No, this Model.Cache.xafml only contains an unchangeable Application Model layer. Administrative (Model.XAFML) and user-specific (e.g. Model.User.XAFML) model differences are not cached (they are meant to be modified once the app is deployed).

    Q: Is generation of this cache file somehow connected with database schema changes?
    A: No.

    Q: Can this cached file be supplied with the installer?
    A: Absolutely. You can generate this file by running your app without the debugger attached and then copy it into your installation program. This manual process may be unnecessary in many cases because the cache file will still be automatically generated after the released application is executed for the first time.

    Q: What about this feature for ASP.NET?
    A: By default, the EnableModelCache property has no effect on an ASP.NET application since a shared application model is usually generated once for all web clients. If you wish, you can manually activate the creation of this cache file by overriding the GetModelCacheFileLocationPath method of your WebApplication descendant.

    Application Model Database Storage Enhancements

    As you know, XAF apps can store user-defined application customizations (layouts, selected skin, etc.) in an application database with the use of the ModelDifferenceDbStore class introduced several releases ago. In this release, we've enhanced functionality in the following ways:

    • Design-time customizations are now always loaded from the Model.xafml file stored in the file system to simplify debugging.
      In other words, for administrative model differences we have returned to the schema we used prior to introduction of ModelDifferenceDbStore. Only user-specific model differences are loaded from the database by default. When required, you can uncomment the XafApplication.CreateCustomModelDifferenceStore event subscription manually. Note that Model.xafml file content will be loaded to the database once the application starts. Further changes to this file will be ignored if the database record already exists for shared model differences. To reload settings from Model.xafml, enable the administrative UI and use the Import Shared Model Difference Action (or delete the Shared Model Difference record and restart).

    • ModelDifferenceDbStore can now be used when the Security System is disabled.
      Currently, if the Security System is enabled, the SecuritySystem.CurrentUserId value is used as the identifier.  The System.Security.Principal.WindowsIdentity.GetCurrent().Name value is used as a user identifier (passed to the IModelDifference.UserId property) when the Security System is disabled. So, you can enable ModelDifferenceDbStore for WinForms applications with the disabled Security System using the approach described here. However, we do not recommended that you enable ModelDifferenceDbStore for unsecured ASP.NET applications because the UserID will be the same for all users. Shared model differences are supported for both WinForms and ASP.NET when the Security System is disabled. 

    • XML settings are now validated before being persisted.
      This is a small usability improvement to simplify error debugging when using ModelDifferenceDbStore and when the administrative UI for editing model differences is enabled in the application as described here. Application administrators will not be able to save invalid XML, e.g. with unclosed tags.


    Non-Persistent Objects Enhancements

    We continue incorporating non-persistent objects support implemented in our most recent releases with the help of the NonPersistentObjectSpace and NonPersistentObjectSpaceProvider classes.

    With this release, you can display persistent objects in a non-persistent object view with much less code. This is possible with the help of the AdditionalObjectSpaces property in the NonPersistentObjectSpace class. It is best to illustrate this improvement with a short code snippet:

    [DomainComponent, DefaultClassOptions]
    public class NonPersistentObject {
        // ... 
        public string Name { get; set; }
        public Person Owner { get; set; }
    public class AdditionalPersonObjectSpaceController : WindowController {
        private IObjectSpace additionalObjectSpace;
        protected override void OnActivated() {
            Application.ObjectSpaceCreated += Application_ObjectSpaceCreated;
            additionalObjectSpace = Application.CreateObjectSpace(typeof(Person));
    private void Application_ObjectSpaceCreated(Object sender, ObjectSpaceCreatedEventArgs e) {
            if (e.ObjectSpace is NonPersistentObjectSpace) {

    Once XAF v16.1 is released, refer to the "How to: Show Persistent Objects in a Non-Persistent Object's View" article in the online documentation for a full tutorial and additional explanations. Also notice the new ORM-agnostic DevExpress.ExpressApp.Data.Key attribute we introduced to mark unique key properties of an object type.


    Another improvement involves showing a non-persistent Detail View: Separately (e.g., from a navigation control or in a popup window) or Embedded (inside a DashboardView item). With XAF v16.1, you can handle the new ObjectByKeyGetting event of the NonPersistentObjectSpace class to provide a non-persistent object instance manually. As an example, consider a scenario when a navigation item pointing to a non-persistent class DetailView was added under the NavigationItems node and its ObjectKey parameter was specified in the Model Editor as shown below:


    You can now add the following Controller to handle this scenario:

    public class NonPersistentObjectsController : WindowController {
        protected override void OnActivated() {
            Application.ObjectSpaceCreated += Application_ObjectSpaceCreated;
        private void Application_ObjectSpaceCreated(object sender, ObjectSpaceCreatedEventArgs e) {
            NonPersistentObjectSpace nonPersistentObjectSpace = e.ObjectSpace as NonPersistentObjectSpace;
            if(nonPersistentObjectSpace != null) {
                nonPersistentObjectSpace.ObjectByKeyGetting += nonPersistentObjectSpace_ObjectByKeyGetting;
        private void nonPersistentObjectSpace_ObjectByKeyGetting(object sender, ObjectByKeyGettingEventArgs e) {
            if(e.ObjectType.IsAssignableFrom(typeof(NonPersistentObject))) {
                if(((int)e.Key) == 138) {
                    NonPersistentObject obj138 = new NonPersistentObject();
                    obj138.Name = "Sample Object";
                    e.Object = obj138;

    If you want to create a non-persistent object automatically for each Detail View, you do not need to specify an ObjectKey in the Model Editor. Leave the ObjectKey value empty and create the following View Controller, which will create a non-persistent object

    public class NonPersistentObjectActivatorController : ViewController<DetailView> {
        protected override void OnActivated() {
            if(ObjectSpace is NonPersistentObjectSpace) {
                View.CurrentObject = View.ObjectTypeInfo.CreateInstance();

    On a final note, let me add that custom calculated fields are now supported as well. In other words, you can define custom fields  for non-persistent types in the Model Editor with the Expression attribute like NonPersistentProperty1 + NonPersistentProperty2.

    Several types have changed their host assemblies without changes in namespaces

    This is just a formal notification as this change should not be "breaking" or affect you at all in the majority of cases. Refer to the Several types have been moved to the DevExpress.Persistent.Base and DevExpress.Persistent.BaseImpl assemblies from the Charts, ConditionalAppearance, KPI and StateMachine modules in XAF v16.1 KB Article for more details.

  • XAF Goes Mobile: CTP Version Ships with v15.2.9

    The eXpressApp Framework (XAF) team has been working hard to add a mobile UI option to your existing or new projects and we are ready for the first public preview. This new feature will let you easily create iOS and Android apps in addition to WinForms and ASP.NET UI options already available to you. The mobile apps will reuse the database, as well as certain aspects of the data model, application logic and UI settings of your existing XAF applications. This will help you avoid all the routine work that would take days or weeks of development efforts if building those mobile apps from scratch.

    XAF Mobile App UI

    We’ve already shown this functionality to a small group of XAF developers at the end of last year and got lots of useful feedback. The team has fixed issues and incorporated a number of improvements and we now feel that the framework is ready to go public. 

    Certain aspects of the new functionality will change and we'd like to think that your feedback will play an important role in that. Please use the resources in this email to evaluate the new features and share your opinion with us.


    Review the Demo App

    Start your evaluation by reviewing a sample mobile application hosted on Azure. Either use the browser-based simulator or try it on your smartphone by simply scanning the QR code.

    Run the Demo


    Build a Mobile App Yourself

    We encourage you to follow the tutorial below to create a mobile app based on your own XAF solution. The article uses the Project Manager demo as an example, but you can apply the same steps to any XAF project.

    Follow the Tutorial


    Review Frequently Asked Questions

    To learn more about the capabilities and limitations of the XAF Mobile UI, review the knowledge base article that answers the most frequently asked questions.

    Read FAQ


    Complete the Survey: Help Prioritize Future Development

    Complete the following survey so we can learn more about the types of application you’re looking to build. We know your time is valuable so we’ve limited it to only 5 questions and the entire survey shouldn’t take longer than 10 minutes.

    Complete the Survey


    Contact Us via the Support Center

    We are also looking forward to your reports via the Support Center. Please submit separate tickets for each problem or question for better tracking. Thank you for your help!

  • XAF – A Simpler Way to Check Database Compatibility (Coming soon in v15.2)


    In earlier versions, to check the compatibility of an application and its database, a ModuleInfo table was created in the database. This table stores information on the module versions used in an application. When checking the compatibility of the database and the application, the versions stored in the ModuleInfo table are compared with actual module versions. A DatabaseVersionMismatch event occurs when there's a mismatch. By default, each module's version is set to "1.0.*" using the AssemblyVersion Attribute in the Properties\AssemblyInfo.cs file. The asterisk sign in the version indicates that the build and revision numbers in the version are autoincremented, and so version value is updated with each new build. As a result, WinForms and ASP.NET module versions may not be synced if you build WinForms and ASP.NET applications separately (e.g, when creating a ClickOnce installation or deploying to IIS).

    With v15.2, we've introduced a new application and database compatibility check mode; one that utilizes native XPO methodologies. In this mode, the following checks are performed:

    1. The database exists.

    2. All required tables exist.

    3. All required columns exist.


    The DatabaseVersionMismatch event occurs if any of these checks fails.

    The new XafApplication.CheckCompatibilityType property specifies which mode to use. The CheckCompatibilityType.ModuleInfo value indicates that the old mode that relies on the ModuleInfo table is used. This mode is still used by default for applications created with earlier versions of XAF. In applications created with the Solution Wizard in version v15.2, the XafApplication.CheckCompatibilityType value is CheckCompatibilityType.DatabaseSchema, which corresponds to the new mode detailed above. This property value can be changed in the Application Designer:

    Untitled (1)


    Note that the use of ModuleInfo is more complicated, but it ensures business logic compatibility in addition to data model compatibility. The new DatabaseSchema mode relies on the database schema only.

    A CheckCompatibilityType property has also been added to the IObjectSpaceProvider interface, allowing you to specify the mode individually for each Object Space Provider (when you use multiple databases). By default, it is set to null and the XafApplication.CheckCompatibilityType value is actually used. Another useful change with this interface is the new  IObjectSpaceProvider.SchemaUpdateMode property. You can now use it to specify handle compatibility checking for the database associated with the current Object Space Provider. The following values are available:

    • DatabaseAndSchema - Missing database is autocreated. The database schema is updated when the compatibility check fails.

    • None - Database compatibility issues are ignored.


    That's my  last post prior to launch and hopefully you've liked what we've done with XAF. As always, we want to hear your thoughts. Please tell us what you think of XAF v15.2.

  • XAF - Enhancements to Core and other modules (Coming soon in v15.2)

    Over the last few days, I've described some of the new features we've introduced into the eXpressApp Framework v15.2. In this post, I'll describe enhancements we've made to XAF's core and other modules.
    Reset View Settings
    The Reset View Settings Action re-opens the current View and resets all user customizations made to the View's model. This Action is disabled (grayed out) if there are unsaved changes.

    Detail Form Layout Customization in Code

    With this release, you can customize the Detail View's default layout in your Data Model code using the DetailViewLayout attribute. Please refer to the following example code/screenshot below:

    public class Contact {
        public int ID { get; private set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        [DetailViewLayoutAttribute("FullName", 0)]
        public string FullName {
            get { return FirstName + " " + LastName; }
        public string Email { get; set; }
        public virtual Contact Manager { get; set; }
        public DateTime? Birthday { get; set; }
        [DetailViewLayoutAttribute("NotesAndRemarks", LayoutGroupType.TabbedGroup, 100)]
        public string Notes { get; set; }
        [DetailViewLayoutAttribute("NotesAndRemarks", LayoutGroupType.TabbedGroup, 100)]
        public string Remarks { get; set; }

    Non-Persistent Objects Enhancements

    In this release we have extended support for usage scenarios when using non-persistent objects first introduced in v15.1:

    • The New, Delete and Save Actions are available for non-persistent objects. Modified objects are accessible using the NonPersistentObjectSpace.ModifiedObjects property.
    • The INotifyPropertyChanged.PropertyChanged event is now triggered for non-persistent objects.
    • The non-persistent Object Space is now accessible for objects that support IObjectSpaceLink.

    Security System Enhancements

    We continue making the new security system more capable with the following updates:

    • Security permissions are immediately refreshed once the administrator applies changes. You are no longer required to log off all affected users to refresh permissions (learn more...).
    • If the administrator grants certain permissions to a reference or collection property that participates in an association (one-to-many or many-to-many), the same permissions are automatically granted for a property at the other end of this association (learn more...).
    • The Data View mode in now supported.
    • Upcasting is now supported in List View columns.
    You should expect more news in this regard after the official release.

    General usability and API improvements:

    The following is a list of minor features that should make using XAF a little easier. While you can see the full list of these smaller enhancements in our What's New docs, I would like to highlight the following items:

    • S38140 - Core - Introduce IObjectSpace.Evaluate method that will evaluate a criteria expression against both EF and XPO objects (including Domain Components)
    • Q483608 - Core - Make it easier to obtain IQueryable<T> collection through IObjectSpace for LINQ
    • S171061 - Core - Provide an option to avoid saving a master record immediately when a new non-aggregated child object is created in a nested List View
    • S170756 - Core - Provide Refresh method overloads allowing the refresh of the underlying data source
    • T204296 - EF.Usability - Support complex types that are not registered in DbContext and have no key property
    • T177760 - EFDataView - Support common criteria function operators
    • S172038 - Core - Provide a simplified database compatibility check mode; one that relies on the database schema and ignores module assembly versions
    • T312781 - ImagePropertyEditor - Support images declared as reference properties instead of byte array
    • T303205 - Workflow - Add an option to repeat the workflow multiple times while the target object fits criteria


    I will post additional content on some of these items (like S172038) separatly, once we release v15.2. Please stay tuned and let us know what you think of these new features.

  • XAF - Web UX Enhancements (Coming soon in v15.2)

    In this release cycle, we've evolved our web page templates and themes optimized for touch devices (released in v15.1). While we still continue to refine things, we believe that this feature is ready to be used in production and we do not expect major breaking changes going forward.

    UPDATE: See also the XAF Goes Mobile: CTP Version Ships with v15.2.9 post to learn more on the related XAF 15.2 feature.

    In addition to numerous cosmetic enhancements and capabilities that were already test-driven in previous minor updates, let me highlight a few important features:

    1. Adaptive and Responsive Layout

    Our ASPxGridListEditor now supports adaptive layouts in the new web style. Columns are collapsed automatically when the browser window is resized.

    To enable this responsive mode, set the ASPxGridListEditor.IsAdaptive property in a ViewController. You can customize this behavior via the IModelColumnWeb.AdaptivePriority property in the Model Editor invoked for the ASP.NET project. 

    This option specifies the column's priority. Columns with a lower AdaptivePriority value remain visible when the browser window shrinks, while columns with a higher value are hidden. Hidden column data can be accessed via the ellipse "..." button. In the image above, both the SUBJECT and PROJECT columns have a lower AdaptivePriority value than others.

    2. Device-Specific Settings in ASP.NET Applications

    Web applications can now have separate settings for desktop, tablet and mobile devices. Device-specific model differences are stored in the Model.Desktop.xafml, Model.Tablet.xafml and Model.Mobile.xafml files. Database settings storage is also supported.

    3. Customizable ASP.NET Templates for Touch Devices

    Page templates designed for touch devices can be easily customized. Corresponding project item templates are now available in Visual Studio:

    • DevExpress v15.2 XAF ASP.NET Default Template Content V2
    • DevExpress v15.2 XAF ASP.NET Dialog Template Content V2
    • DevExpress v15.2 XAF ASP.NET Logon Template Content V2
    • DevExpress v15.2 XAF ASP.NET Nested Frame Control V2


    With v15.2, the DevExpress HTML5 Report Viewer is used by default. 

    Our Web Report Designer now supports parameters with complex types (including multi-value parameters for complex types).

    Finally, XAF's Reports Module can now store a layout in XML format, making complex report rendering much faster (learn more)!

    Confirm unsaved changes

    ASP.NET applications can now prevent loss of unsaved data by displaying a warning dialog if a user attempts to close the browser tab, or clicks an Action whose execution may lead to loss of unsaved data.

    This behavior is enabled by default. You can disable it using the ConfirmUnsavedChanges property of the Options node in the Model Editor invoked for an ASP.NET project:

    The option above is global. To enable/disable the confirmation dialog for a specific Action, use the ConfirmUnsavedChanges property of the ActionDesign | Action node.

    By default, the IModelActionWeb.ConfirmUnsavedChanges option is set to true for the following Actions: NextObject, PreviousObject, New, DialogCancel, DialogClose, ChooseTheme, Refresh, Cancel, Edit, Logoff, ChangeVariant

    Batch Edit support

    ASPxGridListEditor now supports Batch Edit Mode. Unlike other modes, Batch Edit allows you to edit multiple rows and then save all modified objects at the same time.

    To enable Batch Edit Mode, set the InlineEditMode property of the ListView node to Batch in the Model Editor and ensure that the AllowEdit property of the same node is set to true.

    Please note the following: 

        In Batch Edit mode, the Detail View is not invoked when a user clicks a row.
        A few data types cannot be edited: imagesreferencescriteriafile attachments.
        Initial property values for new objects are passed to the client when the grid control is created and are not updated each time you create objects using the New Command Item.

    Batch Edit Mode supports our new ConfirmUnsavedChanges and Validation module features.

    Master-Detail support

    ASPxGridListEditor now provides built-in support for the master-detail data presentation. To enable it, run the Model Editor for an ASP.NET project, and set the DetailRowMode property of the Views | ListView node to DetailView or DetailViewWithActions.

    In DetailViewWithActions mode, a Detail View specified using the DetailRowView property is shown in a detail row. In DetailView mode, the same Detail View is displayed, but the toolbar of its nested List View is hidden.

    By default, DetailRowMode is None and the master-detail mode is disabled.


    Please tell us what you think of these new features.

  • XAF - Web Map Module (Coming soon in v15.2)

    With this release, we're shipping a new Map module for XAF Web apps - allowing you display business objects on different kinds of maps. The module integrates the client-side dxMap and dxVectorMap widgets from DevExtreme into ASP.NET XAF applications via specialized XAF server-side wrappers like List and Property Editors: WebMapsListEditor, WebVectorMapsListEditor and WebMapsPropertyEditor.

    Primary Capabilities

    While designing this module, we considered customer feedback received during the research we conducted earlier this year and also previous user requests from the Support Center and other sources. Let's take a quick look at the functionality implemented in the initial release:

    1. Interactive map displays objects implementing the IMapsMarker interface using the Google Maps API or Bing Maps API:


    2. Vector map displays objects implementing the IAreaInfo interface as areas with different colors:


    3. Vector map displays objects implementing the IVectorMapsPieMarker interface as pie-chart markers:


    You can experience a live demo of our Map module in the ListEditors | Maps section of the offline Feature Center demo that is installed with XAF or check its online version at once v15.2 is officially released.


    You can configure map types via the Model Editor invoked from Visual Studio or in code:

    1. Configuring WebMapsPropertyEditor for a DetailView:

    2. Configuring WebVectorMapsListEditor for a ListView:

    3. Customizing the underlying dxMap widget in code of a ViewController for a ListView:

    using DevExpress.Persistent.Base;

    namespace DevExpress.ExpressApp.Maps.Web.Controllers {

       public class MapCenterController : ObjectViewController<ListView, Store> {

           protected override void OnViewControlsCreated() {


               ((WebMapsListEditor)View.Editor).MapViewer.ClientSideEvents.Customize = GetCustomizeScript();


           private string GetCustomizeScript() {

               return @"function(sender, map) {

           map.option('center', 'Brooklyn Bridge,New York,NY');

                          map.option('autoAdjust', false);






    We'd love to get your feedback on this new Map module and whether you are planning to use it in upcoming XAF Web apps.

  • XAF - Validation Module Enhancements for Windows and the Web (Coming soon in v15.2)

    In our upcoming release of the eXpressApp Framework, data validation occurs immediately after input focus changes when validation rule evaluation does not require querying additional data from the server. These rules are RuleRequiredField,RuleRegularExpressionRuleStringComparisonRuleValueComparison and RuleRange.

    In-place validation is enabled for the Save context by default. To enable it for other contexts, use the AllowInplaceValidation property of the Validation | Contexts | Context node in the Model Editor.

    Since rule evaluation occurs on the client side, in-place validation does not occur when:

    The asterisk (*) symbol is automatically appended to an editor label when the RuleRequiredField is applied.

    In-place validation engine relies on Controllers provided in our platform-specific ValidationWindowsFormsModule and ValidationAspNetModule components.

    Note: The ASP.NET module was introduced in v15.2. In order to use in-place validation after upgrading your existing ASP.NET applications to v15.2, be certain to add  this module from the Toolbox into the Application Designer.


    The XAF Team would love your feedback. Please tell us what you think of these new features.

  • XAF: A preview of the HTML5/JS Report Document Viewer integration in Web UI (Shipping in v15.1.5)

    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:



    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.

  • XAF: Enhancements to App UI Management Settings in the Database (Shipping in v15.1)

    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.     
  • XAF: Enhancements to existing modules, Entity Framework and performance (Coming soon in v15.1)

    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 ticketTake 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!

2 3 4 5 6 7 8 9 10

Chat is one of the many ways you can contact members of the DevExpress Team.
We are available Monday-Friday between 7:30am and 4:30pm Pacific Time.

If you need additional product information, write to us at or call us at +1 (818) 844-3383


DevExpress engineers feature-complete Presentation Controls, IDE Productivity Tools, Business Application Frameworks, and Reporting Systems for Visual Studio, along with high-performance HTML JS Mobile Frameworks for developers targeting iOS, Android and Windows Phone. Whether using WPF, ASP.NET, WinForms, HTML5 or Windows 10, DevExpress tools help you build and deliver your best in the shortest time possible.

Copyright © 1998-2016 Developer Express Inc.
All trademarks or registered trademarks are property of their respective owners