Xaf on ZeroSharp

Smart hiding of the selection boxes in XAF web applications

Sun, 06 Nov 2016 18:39:00 +0100

When an XAF list view has no selection-based actions available, the selection box still appears in the grid. Users get confused. In this post, we’ll look at a workaround.

The problem

In the XAF MainDemo, lets make Departments read-only for the User role.

1
2
3


userRole.AddTypePermissionsRecursively<Department>(SecurityOperations.Create, SecurityPermissionState.Deny);
userRole.AddTypePermissionsRecursively<Department>(SecurityOperations.Write, SecurityPermissionState.Deny);
userRole.AddTypePermissionsRecursively<Department>(SecurityOperations.Delete, SecurityPermissionState.Deny);

Then start the web application, login as John and navigate to the Departments list view. There is a column selection box, but it serves no purpose. There are no actions that depend on a grid selection.

An XAF workaround for 'Prevent this page from creating additional dialogs.'

Mon, 16 May 2016 13:51:00 +0100

Both Chrome and Firefox have a ‘feature’ which allows a user to ignore future calls to confirm(). Once this has been checked, any subsequent calls to confirm() return false immediately without showing the window.

In XAF, this behaviour prevents the application from working correctly. For instance, it becomes impossible to confirm a deletion.

The following controller provides a work around. It injects some javascript into the page wrapping the call to confirm(). The new code detects when the Prevent this page from creating additional dialogs checkbox has been checked and returns true instead. The confirmation window still does not appear, but the XAF application works as if the user had pressed confirm instead of cancel.

DevExpress 2015.2 review part 2

Thu, 10 Dec 2015 09:43:00 +0100

This is the second and final dive into some of the new DevExpress XAF 2015.2 features. The first part covers the Report Designer and the new XML serialisation.

Batch editing

Another feature I’m excited about is the support for batch editing within the web application grids.

Let’s see what happens when combined with the validation rules. What happens if I edit two rows but only one has a validation problem - does the whole batch get rejected? Or just the row with the problem?

DevExpress 2015.2 review part 1

Wed, 09 Dec 2015 14:43:00 +0100

Last week, DevExpress released 2015.2.3, their second major version of the year.

There are already some good blog posts about the changes:

Rather than repeat general overviews provided in these, this two-part blog post is more of a ‘deep dive’. In particular I’ll be looking at two of the new features in the expressApp Framework (XAF). Today I’ll cover the new XML serialisation in the report designer. Tomorrow’s post will examine the new batch editing features.

Migrating a large web application from XAF 12.1 to 15.1 - Part 3

Wed, 16 Sep 2015 09:39:00 +0100

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.

Migrating a large web application from XAF 12.1 to 15.1 - Part 2

Tue, 15 Sep 2015 10:37:00 +0100

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.

Migrating a large web application from XAF 12.1 to 15.1 - Part 1

Mon, 14 Sep 2015 10:01:00 +0100

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:

Force a complete garbage collection in an ASP.NET application.

Wed, 05 Aug 2015 09:26:00 +0100

How can I force a full garbage collection easily within an ASP.NET application? The method here is for XAF web applications but the same approach should work with any ASP.NET app.

First up: Never mess with the .NET garbage collector.

I sometimes mess with the garbage collector in .NET when I’m trying to pin down some memory problem. Also, after a load test, I prefer to force the garbage collector to collect everything it can so that I can check that the memory drops as expected.

Fixing slow debugging of ASP.NET applications

Wed, 03 Jun 2015 21:31:00 +0100

For a while I’ve noticed an annoying slowness when debugging ASP.NET applications from Visual Studio. Just after every page load it takes about a second before the buttons become clickable. I noticed mostly when debugging XAF applications, perhaps because the pages are quite complex.

Turns out the culprit is something called Browser Link which was introduced in Visual Studio 2013. It’s enabled by default.

To turn it off you can turn it off from the menu:

DevExpress 14.2 review

Tue, 20 Jan 2015 08:35:00 +0100

This post is an overview of the brand new version XAF 14.2. The truly outstanding new feature is the ASP.NET report writer which is now available in all XAF applications.

A few months ago, we lost a potential sale because the customer wanted the ability to create custom reports from within the browser. We told them it was impossible to provide a fully-fledged report designer within our web application - but the DevExpress guys have done it! And how!

ELMAH with DevExpress XAF

Wed, 08 Oct 2014 15:45:00 +0100

ELMAH (Error Logging Modules and Handlers) is an open source library for logging unhandled exceptions. This post explains how to get it running with the DevExpress XAF main demo.

A couple of amazing facts about ELMAH.

It has been around since 2004!
It was written by Atif Aziz who happens to be an old school-friend from the International School of Geneva.

XAF provides quite extensive error handling options out of the box, but I have found Elmah better suited to production environments because of the ability to remotely view the full error log.

A web UI performance tip for XAF web applications

Mon, 31 Mar 2014 10:16:00 +0100

The purpose of this post is to raise your awareness of a toggle which exists in the DevExpress XAF framework which can significantly improve UI performance in the web application.

The biggest XAF project I work with has one very complex business object. The layout for this screen includes about 100 properties, several nested tabs, some custom editors, several collection properties and a whole lot of Conditional Appearance rules. It was very sluggish to navigate - it was taking several seconds to load the detail view and then it was very slow switching between tabs. Switching to edit mode was also slow.

Provisioning a new development machine with BoxStarter

Tue, 25 Feb 2014 15:29:00 +0100

I’ve been playing around with Boxstarter to configure my entire development environment with hardly any user intervention.

Here are the steps:

Install Windows 8.1 on a new machine.
Login.
Open a command prompt and enter the following.

START http://boxstarter.org/package/nr/url?http://bit.ly/1kapDXI

That’s it!

Boxstarter will self-install via ClickOnce, asking for various confirmations and ultimately it will prompt you for your login password. (This gets saved and encrypted to allow for unattended reboots and re-logins during the installation). Then the real magic begins. Boxstarter downloads and installs all your tools and configures your environment, rebooting as necessary. An hour later your full development setup is installed, including Visual Studio 2013, any VS extensions, any other programs and tools, all the browsers you need, all critical Windows updates, etc. You just saved yourself a couple of days of work and a lot of hassle.

Glimpse with DevExpress XAF

Tue, 17 Dec 2013 12:41:00 +0100

I have finally got around to getting Glimpse working with XAF. Glimpse is an amazing extensible ASP.NET plug-in which gives you valuable information about what is going on within your server in production. It’s also very pretty.

Let’s jump right in and have a look at what XAF looks like with Glimpse running.

That banner along the bottom of the screen is the Glimpse heads up display (HUD). Hovering over various sections of it pops up more information:

DevExpress 13.2 Review - Part 2

Tue, 10 Dec 2013 16:10:00 +0100

This is the second part of a review of the new DevExpress 13.2. In the last part we looked in-depth at the new Reports V2. In this part I’ll go over some of the other new features including the support for warnings and confirmations in the validation module.

Soft Validation Rules

With 13.2, DevExpress adds support for warning/confirmation messages to the validation engine. Warnings can be used to handle an unusual but valid data entry. An example would be:

DevExpress 13.2 Review - Part 1

Mon, 02 Dec 2013 16:23:00 +0100

The first version of XAF I ever installed was called eXpressApp-1.0.CTP2.exe in July 2006! It has certainly come a long way since then.

This post is the first part of an overview of the brand new version XAF 13.2 which will be released any day now. This part is an in-depth review of the new report writer features (still in beta).

Reports V2

Prior to this version, XAF reports were not source code. They were objects serialized to a file and then loaded into the database during initialisation. This has a lot of shortcomings some of which I have addressed in previous blog posts.

How to improve XAF grid layout for Chrome

Fri, 08 Nov 2013 09:55:00 +0100

This post proposes a workaround for a specific XAF rendering problem related to recent versions of Google Chrome.

Here is an XAF list view as it looks with IE 10 and DevExpress 13.1.8.

This is how the same view looks with Chrome 30. Notice how the column widths are rendered poorly. The minimum space is given to the string field and the date and bool fields are too wide.

Three ways to store a list of currency codes in XAF

Tue, 22 Oct 2013 18:15:00 +0100

In the last post we looked at three solutions to a relatively simple XAF requirement. In this post I’ll discuss another XAF challenge, explain the options and provide a versatile and maintainable solution.

In my DevExpress XAF application, I have an object which has several properties like this:

In each case, the field is a comma-separated list of currency codes. These fields are not very important to the model - they are used mainly for reporting.

The Ugly, the Heavy and the Good: 3 solutions to an XAF layout problem

Mon, 14 Oct 2013 09:51:00 +0100

This post aims to look at various solutions to a seemingly simple layout change.

With DevExpress XAF, a lot of the difficult things are easy: authentication, authorisation, ORM, reporting, complex form layouts, themes, etc., are all made easy by XAF. On the other hand, some of the easy things are hard. It can be frustratingly difficult to make a small modification to the basic layout. We will look at an example of such a change and evaluate the recommended DevExpress approaches.

A review of NDepend 5

Wed, 02 Oct 2013 17:54:00 +0100

NDepend is a commercial static analysis tool for .NET managed code. It’s been around a long time (since 2004!). Version 5 was just released and in this post I’m going to try it out on the DevExpress MainDemo.

In the past I have always thought of NDepend as a complex tool. I was never sure where to start. In version 5, a lot of work has been done to improve the learning curve. The installation process is easy and a wizard very quickly points you in the right direction.

MiniProfiler with DevExpress XAF

Tue, 27 Aug 2013 09:14:00 +0100

In this post I will demonstrate how to add MiniProfiler to the XAF MainDemo web application.

MiniProfiler is a simple fast profiler with a pretty user interface. It is fast because it only profiles code that you have explicitly decorated with the MiniProfiler.Step() method. It was designed by the team at StackOverflow.

First, add the MiniProfiler NuGet package to the MainDemo.Web project. Then add a placeholder to default.aspx just before the last <body> tag.

Fluent queries with DevExpress XPO - Implementation

Wed, 14 Aug 2013 11:03:00 +0100

Continuing from my last post, I’ll demonstrate how to create a fluent interface so that you can do:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


var customer = Session
 .Query()
 .InTransaction
 .Contacts
 .ByPosition("Developer")
 .ThatHave
 .NoPhoto()
 .And
 .TasksInProgress()
 .And
 .TasksWith(Priority.High) 
 .FirstOrDefault();

First, let’s look at the ‘beginning’ of the fluent interface: the Query() extension method.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


public static class QueryExtensions
{
 public static IQueries Query(this Session session)
 {
 return new Queries(session);
 }

 // If we're using XAF, do the same for ObjectSpace as well
 public static IQueries Query(this IObjectSpace objectSpace)
 {
 var xpObjectSpace = objectSpace as XPObjectSpace;
 var session = xpObjectSpace.Session;
 return new Queries(session);
 }
}

What does the Queries() class look like?

Fluent queries with DevExpress XPO - Intro

Mon, 12 Aug 2013 17:54:00 +0100

There are many ways to perform queries with XPO.

You can do this:

1

 Session.FindObject<Contact>(new BinaryOperator("Name", "Elvis"));

or this

1

 Session.FindObject<Contact>(CriteriaOperator.Parse("Name = 'Elvis'"));

Another way to use the simplified criteria syntax, and with the Xpo_EasyFields CodeRush plugin. Then you can do:

1

Session.FindObject<Contact>(Customer.Fields.Name == "Elvis");

For each of the above, you can optionally query within the transaction by passing in the PersistentCriteriaEvaluationBehavior.InTransaction parameter.

Or we can use LINQ via XPQuery<T>.TransformExpression().

Session.FindObject<Contact>(
 XPQuery<Contact>.TransformExpression(Session, c => c.Name == "Elvis")
 );

All of these methods are powerful, but the power comes at a cost. The syntax is neither elegant nor particularly clear and as a result it is not very practical to maintain or test.

Making XAF reports even better - Part 2

Tue, 28 May 2013 11:51:00 +0100

Good news. The conversion is now two-way. Get the source code from GitHub. Make sure you have built MainDemo.Reports project.

You will find there are now two T4 transforms in the project. RepxToCSharp.tt is covered in the Part 1. It searches for any .repx files in the solution and converts the scripts into compilable C#.

The second transform is new. CSharpToRepx.tt copies any changes to the script part back into the original .repx files. Again, there are performance optimisations via checksums to prevent overwriting unchanged files.

Making XAF reports even better - Part 1

Tue, 21 May 2013 14:38:00 +0100

The ability to create reports using a report writer is a very powerful feature of DevExpress XAF, but there are some limitations which are particularly cumbersome to deal with in complex project.

One of the projects I work on has over 100 reports in it. Even though we make use of unit tests to ensure they are not broken, the maintenance of the code in the embedded scripts is particularly difficult to manage.

Load Testing XAF: Bonus - Simultaneous EasyTests

Mon, 22 Apr 2013 16:31:00 +0100

In my recent series on load testing XAF, I used a Selenium javascript test to run the client browser instances. This is a good and cheap method of validating the performance of XAF applications under production load.

However, if the load tests fail because of a concurrency bug or a performance bottleneck, it can still be difficult to analyse and solve. For this, we need to be able to simulate load locally against the development environment.

Load Testing XAF: Part 5 - Analysis

Sun, 14 Apr 2013 07:37:00 +0100

This is the final post in a series about load testing XAF applications. Previously in the series:

In this part, we analyse the results of the load test we ran in Part 4.

Results

The results of the test we ran are here. The graphs are interactive and give quite interesting data about the load tests. Feel free to have a look and play around with the results.

Load Testing XAF: Part 4 - Launching the load test

Mon, 08 Apr 2013 11:19:00 +0100

This is another post in a series about load testing XAF applications. Previously in the series:

In this part, we will launch a 1 hour test with 25 virtual users using the NeuStar Web Performance Management module.

Schedule and launch a test

From the script validation screen, click on Schedule a load test with this script. The defaults are good, but you can specify in detail how to run your load test. For instance, you can coordinate multiple Selenium scripts to simulate different types of activity on your site.

Load Testing XAF: Part 3 - Uploading and Validating the Virtual User Script

Wed, 03 Apr 2013 16:39:00 +0100

This is another post in a series about load testing XAF applications. Previously in the series:

In this part, we will load test the application we set up in Part 1, using the Selenium load test we created in Part 2.

Neustar Web Performance Management

NeuStar (formerly BrowserMob) are a company specialised in web application performance monitoring. We are interested in their web performance module. It is free to create an account. To run a test with less than 25 virtual users costs only $0.15 per virtual user. Tests with more than 25 users (up to 5000) require an additional paid plan.

Load Testing XAF: Part 2 - Selenium

Thu, 28 Mar 2013 16:56:00 +0100

Writing a Selenium User Test against MainDemo

This is another post in a series about load testing XAF applications. Previously in the series:

Why not use DevExpress EasyTests?

The DevExpress recommended method of writing functional tests is to use the EasyTest functionality of the expressAppFramework. This has several advantages over other functional testing approaches.

It uses a domain specific language tailored for XAF making it easy to test views and actions
It makes it easy to interact with the DevExpress controls that are used within XAF
A single EasyTest can be run against both the ASP.NET and WinForms applications
EasyTests work against both the debug webserver and IIS

However, one feature which is not (yet) available is the ability to use EasyTests for load testing.

Load Testing XAF: Part 1 - Deploying

Fri, 22 Mar 2013 11:21:00 +0100

This is the first part of a tutorial about load testing XAF applications. See the overview for a bit of background. In this post we set up the target webserver.

You can target any machine which has a publicly available web address, but for this tutorial, I’m’ deploying the MainDemo to the Amazon cloud, by following the instructions in Part 1 and Part 2 of my previous series about Amazon Web Services.

I am using version 12.2.7 of the DevExpress XAF MainDemo. There are a couple of extra changes to make to the web.config.

Load Testing XAF: Overview

Tue, 12 Mar 2013 18:20:00 +0100

Over the next few posts, I will demonstrate how to load test XAF web applications.

History

Performance testing has traditionally been difficult and expensive. A few years ago, to do it well required a powerful piece of dedicated load testing software such as HP LoadRunner (typical cost back in 2007: USD 50,000-100,000 or more per year!). This software was capable of simulating multiple virtual users via the use of recorded scripts and providing detailed performance statistics. Usually the cost was increased further increased by the need for powerful hardware to be able to run the application.

Better handling of Decimals in the XAF audit trail

Tue, 15 Jan 2013 10:29:00 +0100

The following screenshot shows the detail view of an object change from the DevExpress XAF Audit Trail. The DecimalValue property was changed from 123.45 to 543.22.

Why is the OldValue property is displayed with two trailing zeros? The corresponding property is defined as follows:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37



[DefaultClassOptions]
public class MyClass : XPObject
{
 public MyClass(Session session)
 : base(session)
 { }

 //...

 private decimal _DecimalValue;
 [ModelDefault("DisplayFormat", "{0:n2}")]
 public decimal DecimalValue
 {
 get
 {
 return _DecimalValue;
 }
 set
 {
 SetPropertyValue("DecimalValue", ref _DecimalValue, value);
 }
 }

 private XPCollection<AuditDataItemPersistent> _ChangeHistory;
 public XPCollection<AuditDataItemPersistent> ChangeHistory
 {
 get
 {
 if (_ChangeHistory == null)
 {
 _ChangeHistory = AuditedObjectWeakReference.GetAuditTrail(Session, this);
 }
 return _ChangeHistory;
 }
 }
}

Explanation and fix

A C# decimal is a type which represents a number’s value and its precision. It actually stores the number of trailing zeros along with the value. For the NewValue, it has stored the decimal value as the user entered it - with no trailing zeros. Howevever, for the OldValue, it has retrieved the value from the database and used the SQL column definition to determine the precision.

Deploy XAF ASP.NET Applications to Amazon Web Services: Part 5

Wed, 05 Dec 2012 11:03:00 +0100

Part 5: Load balancing

This is the final post in this 5 part series about deploying XAF to the Amazon cloud. The other parts are:

This part covers load balancing and autoscaling.

Load balancing

In order to enable load balancing with DevExpress XAF applications, you must activate client affinity (sticky sessions) which you can do in the Load Balancer tab.

Deploy XAF ASP.NET Applications to Amazon Web Services: Part 4

Mon, 05 Nov 2012 14:16:00 +0100

Part 4: Incremental Deployment

This is the fourth post in a series about deploying ASP.NET applications to the Amazon cloud. In the first three posts covered deploying the XAF ASP.NET MainDemo to the Amazon cloud (Part 1, Part 2, Part 3).

When we deployed to the Elastic Beanstalk in Part 2, we chose not to enable incremental deployment.

I want to explain this decision further.

If you choose not to deploy incrementally your deployment will take longer because the entire web deployment package needs to be uploaded every time you re-publish which takes about 4-5 minutes on my connection. The incremental deployment option creates a git repository in the target environment so that only the modified files are re-deployed. If you are frequently making changes and redploying, you can save considerable time. A re-deployment takes only a few seconds.

Deploy XAF ASP.NET Applications to Amazon Web Services: Part 3

Fri, 02 Nov 2012 17:54:00 +0100

Part 3: Troubleshooting

This is the third post in a series about deploying ASP.NET applications to the Amazon cloud.

In Part 1 we created an Amazon RDS instance of SQL Server to act as the database for the deployment.

In Part 2 we published the DevExpress MainDemo.Web to the Amazon Elastic Beanstalk.

In this part we will look at troubleshooting methods and in particular how to connect to an EC2 instance in order to troubleshoot installations.

Deploy XAF ASP.NET Applications to Amazon Web Services: Part 2

Wed, 31 Oct 2012 12:52:00 +0100

Part 2: Publishing MainDemo

This is the second post in a series about deploying ASP.NET applications to the Amazon cloud.

In Part 1 we created an Amazon RDS instance of SQL Server to act as the database for the deployment. Make sure this is up and running before continuing.

This part guides you through publishing the DevExpress XAF MainDemo application to the Amazon Elastic Beanstalk.

Amazon Elastic Beanstalk

Amazon Elastic Beanstalk provides automatic capacity provisioning, load balancing, auto-scaling, and application health monitoring. That sounds like a lot of features we don’t really need for the MainDemo, so let me explain.

Deploy XAF ASP.NET Applications to Amazon Web Services: Part 1

Tue, 23 Oct 2012 12:52:00 +0100

Part 1: Putting the Database in the Cloud

This is the first part of a tutorial for installing the DevExpress MainDemo.Web to Amazon Web Services, but the same principles apply to any ASP.NET web application.

This part covers creating an Amazon RDS instance running SQL Server Express and connecting a (locally running) MainDemo to it.

At the time of writing the DevExpress version is 12.1.7.

Amazon Web Services

If you have not already done so, you will need to sign up with Amazon Web Services. There are costs associated with AWS, but the tutorial only uses very small cheap instances which cost as little as 2 cents per hour to run. Also, new customers get a load of hours for free as part of the AWS Free Usage Tier. See the AWS pricing for more information. Don’t forget to terminate your instances when you have finished.

A look at the DevExpress MainDemo with Google Page Speed

Wed, 12 Sep 2012 17:22:00 +0100

In this post I’ll demonstrate how to use the Google Page Speed tools to analyse the performance of the DevExpress XAF MainDemo.

The easiest way to run Google Page Speed is as a Chrome or Firefox plugin. Both are available here. I use Chrome.

Now open the DevExpress MainDemo from Visual Studio. By default it is installed to:

C:\Users\Public\Documents\DXperience 12.1 Demos\eXpressApp Framework\MainDemo\CS\MainDemo.sln

Set the MainDemo.Web as the startup project and change the connection string in web.config if necessary. Launch the application with Chrome and login as ‘Sam’ (password is blank). Then press F12 to bring up the developer tools. The last tab is the Page Speed Analysis and your browser should look like this:

Testing the property signatures of DevExpress validation rules using NUnit and LINQ

Thu, 24 May 2012 16:39:00 +0100

One of the projects I work on uses the validation module of the eXpressApp Framework (XAF). Since the business logic is complex, there are many validation rules defined using the [RuleFromBoolProperty].

One of the recurring problems occurs when the signature of the associated property is incorrect. Consider the following:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


[RuleFromBoolProperty("Invoice_IsAmountGreaterThanZero", 
 DefaultContexts.Save, 
 "Invoice amount must be greater than zero.", 
 UsedProperties = "Amount")]
public bool IsAmountGreaterThanZero
{
 get
 {
 return Amount > 0;
 }
}

Notice that the rule is declared public. This causes the getter to be executed when it is not required (see the note in the documentation). However another problem is that the default behaviour for public properties of XPObjects is to persist them to the datastore which means the application will attempt to create a new column called IsAmountGreaterThanZero.