A.Bekiaris's .Net / XAF Blog

Compile your solution without DevExpress assemblies installed in 4 lines

noreply@blogger.com (Apostolis Bekiaris) — Mon, 28 Jan 2019 06:57:00 +0200

Do you have a project, where you use Azure pipelines to build it? How do you get the referenced DevExpress assemblies? In this post I will discuss how we go for it in eXpandFramework. The process however is applicable in all other projects.

After executing the next 4 lines your solution should compile:

Install-Module XpandPosh
Register-PackageSource –ProviderName Nuget –Name DX_private –Location https://nuget.devexpress.com/YOURTOKEN
Install-DX -binPath YOURBIN -dxSources $(Get-PackageSourceLocations -join ";") -sourcePath YOURSOURCESPATH -dxVersion 18.2.5 
Update-HintPath –OutputPath YOURBIN –SourcesPath YOURSOURCESPATH

For feedback drop an issue at https://github.com/eXpandFramework/DevExpress.PackageContent

Easy asynchronous web notifications

noreply@blogger.com (Apostolis Bekiaris) — Thu, 11 Oct 2018 12:25:00 +0300

Today we will discuss another common case, how to create a progress bar to notify our web users about the state of their long running tasks. For this discussion we will work with DevExpress XAF Business Application Framework. We will develop ONE SMALL CLASS, we can then copy paste to any XAF project.

It is a good idea before starting any work to search the Support Center for ideas and ask the DevExpress support guys. Doing so we found many tickets with ready to work solutions. Some of them are good candidates e.g How to start a long running operation in ASP.NET application using the ThreadPool.QueueUserWorkItem method and show its progress in a browser using a WebService method.

The problem with the previous sample , is that uses a WebService to periodically call back in a Controller. I wanted to create a reusable implementation inside a library and a WebService cannot live in a library.
But I got the idea on how to proceed. I just need to create a ViewItem to host a ASPxProgressBar and with periodic call-backs I will inject JavaScript code to SetPosition on the client side ASPxClientProgressbar

Step 1
First we need a sample project so let’s use the XAF New Solution Wizard to create a new Web Project. We do not need any extra modules or security, just create it as simple as possible. After the solution is created add a very simple Domain Object so XAF can generate a web View for it.

    [DefaultClassOptions]
    public class MyObject : BaseObject {
        public MyObject(Session session) : base(session) { }
    }

Step 2
In addition we need create a sequence of Tasks that will return the state of our work. You can use any technology you prefer e.g. webservices, TPL tasks etc. as long as it returns asynchronously it fits our case. For this discussion I will use the System.Reactive library. To create the sequence the next line will be enough.

Observable
    .Interval(TimeSpan.FromMilliseconds(1000))
    .Subscribe(l =>  Console.WriteLine($"Task {l} completed on Thread:Environment.CurrentManagedThreadId}"));

If you want to test how it behaves add it in a console app and you should see the following output.

Step 3
In XAF we use Controllers to communicate with our Views so let’s create a very simple Controller and add our sequence and later connect the progress bar.

    public class MyController : ViewController<DetailView> {
        public MyController() {
            var action = new SimpleAction(this, "StartLongOperation", PredefinedCategory.Tools);
            action.Execute += action_Execute;
        }

        void action_Execute(object sender, SimpleActionExecuteEventArgs e) {
            Observable.Interval(TimeSpan.FromMilliseconds(1000)).Subscribe();
        }
    }

This controller declares an StartLongOperation Action and starts our sequence, exactly as described on XAF docs.
Currently XAF already generated the web UI and actions. Here how the DetailView of MyObject looks like.

Step 4
Now its time to create the progress bar container. For this scenario we do not need to alter the state of MyObject so we will follow the XAF docs on how to create a ViewItem rather than a PropertyEditor. (How to implement a ViewItem). Our starting ViewItem comes next:

    public interface IModelProgressViewItem : IModelViewItem {
    }

    [ViewItem(typeof(IModelProgressViewItem))]
    public class ProgresViewItem : ViewItem {
        public ASPxProgressBar ProgressBar{ get; private set; }

        public ProgresViewItem(IModelProgressViewItem info, Type classType)
            : base(classType, info.Id){
        }

        protected override object CreateControlCore() {
            ProgressBar = new ASPxProgressBar();
            return ProgressBar;
        }

    }

We override the CreateControlCore method and just return an ASPxProgressBar component included in DevExpress suite.
Step 5
As I mentioned before this sample (How to start a long running operation in ASP.NET application using the ThreadPool.QueueUserWorkItem method and show its progress in a browser using a WebService method) use a Javascript Timer to periodically call a WebService which communicates with a XAF Controller.

Our scenario is very similar but we need to remove the dependency to the WebService because we need to push the implementation to our ExcelImporter module that is part of the eXpandFramework and is very hard to host a WebService in a library so it can be reusable and with friction-less installation.

So let’s introduce the Javascript timer in our ProgressViewItem and use Callbacks to notify the server instead of the WebService used in the SC sample. This is as always well document in the XAF docs (How to: Raise XAF Callbacks from Client-Side Events and Process these Callbacks on Server).

        private XafCallbackManager CallbackManager => ((ICallbackManagerHolder)WebWindow.CurrentRequestPage).CallbackManager;
        public int PollingInterval{ get; set; }
        public void Start(int maximum){
            var script = CallbackManager.GetScript(_handlerId, $"'{ProgressBar.ClientInstanceName}'","",false);
            ProgressBar.ClientSideEvents.Init =
                $@"function(s,e) {{ 
                        if(window.timer) window.clearInterval(window.timer);
                        var controlToUpdate = s;
                        window.timer = window.setInterval(function(){{
                        var previous = startProgress;startProgress = function () {{ }}; //this line disables the Loading Panel see Q427477 in SC
                        {script}startProgress = previous;}},
            {PollingInterval});}}";
        }

In short the Start method use the build-in XAF CallBackManager to generate a script with one parameter the ProgressBar.ClientInstance name. We pass this parameter because we may want to use multiple progress-bars in the same view. Next the timer calls this script every PollingInterval.

Whats left is to implement the IXafCallbackHandler as shown.

        public long Position{ get; set; }
        public void ProcessAction(string parameter){
            var script = $"{parameter}.SetPosition('{Position}')";
            WebWindow.CurrentRequestWindow.RegisterStartupScript(_handlerId,script,true);
        }

Here we just created a script that uses the client side ASPxProgressBar API to SetPosition based on the new ProgressViewItem Position property.
Step 6
To consume the ProgressViewItem we modify the MyController defined in Step 3 like:

        void action_Execute(object sender, SimpleActionExecuteEventArgs e) {
            var progresViewItem = View.GetItems<ProgresViewItem>().First();
            progresViewItem.Start(maximum:100);//Start the timer
            Observable
                .Interval(TimeSpan.FromMilliseconds(1000))
                .Subscribe(l => progresViewItem.Position=l );//Update the position for each Task
        }

Step 7
Finally let's add our ProgressViewItem to the a View. We will use the Model editor to create it and drag & drop to the Layout.

Below you can see how the ProgressViewItem works in runtime in our sample solution.

I wrote this post as a proof of concept rather than a complete implementation, so I am not posting any samples. However you can download the the complete ProgressViewItem used if you wish from this gist.
Below you can verify that it works fine in a real world complex module like the ExcelImporter.

XAF can do Mobile and Windows as well, a Mobile implementation for this scenario does not make much sense but have a look how it looks in the Windows platform.

gist

Scheduled long running tasks with XAF

noreply@blogger.com (Apostolis Bekiaris) — Wed, 15 Aug 2018 16:31:00 +0300

Today I will detail about implementing Scheduled Long running tasks in an abstract and reusable way.

The Requirement

Usually, in my solution I have business objects that store time depended data e.g. Exceptions, Logs etc. There is a need to periodically clean up those tables.

The parameters

First we need to identify the problem parameters so we can create a model interface. Parameterizing the problem in a model interface is very useful, because the end user can switch it off if something goes wrong.
Parameters will be: the business object type which we want to clear its records, the criterion to filter the objects and the time to execute this action. The interface along with its registration for this is bellow.

using System;
using System.ComponentModel;
using DevExpress.ExpressApp;
using DevExpress.ExpressApp.Model;
using DevExpress.ExpressApp.Model.Core;

namespace PurgingRule.Module.Controllers{
    //rules container
    public interface IModelClassPurgingRules:IModelClass{
        IModelPurgingRules PurgingRules{ get; }
    }

    [ModelNodesGenerator(typeof (PurgingRulesModelNodesGenerator))] 
    public interface IModelPurgingRules : IModelNode, IModelList<IModelPurgingRule>{
    }

    public interface IModelPurgingRule:IModelNode{
        string Criteria{ get; set; }
        bool ExecuteOnApplicationStart{ get; set; }
        TimeSpan TimeSpan{ get; set; }
        [DefaultValue(500)]
        int ChunkSize{ get; set; }
    }

    //will help us generated more rules if needed
    public class PurgingRulesModelNodesGenerator:ModelNodesGeneratorBase{
        protected override void GenerateNodesCore(ModelNode node){
            
        }
    }

    public class PurgingController:Controller,IModelExtender{

        //model interface registration
        public void ExtendModelInterfaces(ModelInterfaceExtenders extenders){
            extenders.Add<IModelClass,IModelClassPurgingRules>();
        }
    }
}

Now, it is possible to use the Model Editor to configure in which object we want to apply our rules.

That's nice!

But I like to use an Editor to write the Criteria and need to add a few more bits for this to happen. For this we need to use the CriteriaOptions and Editor attributes as shown:

    public interface IModelPurgingRule:IModelNode{
        [Editor("DevExpress.ExpressApp.Win.Core.ModelEditor.CriteriaModelEditorControl, DevExpress.ExpressApp.Win" + XafAssemblyInfo.VersionSuffix + XafAssemblyInfo.AssemblyNamePostfix, typeof(UITypeEditor))]
        [CriteriaOptions("TypeInfo")]
        string Criteria{ get; set; }
        [Browsable(false)]
        [ModelValueCalculator("((IModelClass) Parent.Parent).TypeInfo")]
        ITypeInfo TypeInfo { get; }

Now it should be straight forward to construct any criterion with the help of this build-in editor.

Making Thread Safe Database calls

Working in a multi threaded environment (long running tasks) is build-in in XAF's XPO ORM so we go for it. Just make sure you enable the switch as bellow.

        protected override void CreateDefaultObjectSpaceProvider(CreateCustomObjectSpaceProviderEventArgs args) {
            var threadSafe = true //enable threadsafe;
            args.ObjectSpaceProviders.Add(new XPObjectSpaceProvider(XPObjectSpaceProvider.GetDataStoreProvider(args.ConnectionString, args.Connection, true), threadSafe));
            args.ObjectSpaceProviders.Add(new NonPersistentObjectSpaceProvider(TypesInfo, null));
        }

Scheduling the long running tasks

We will use the StartNewPeriodic extension method and will follow the next steps in our code.

Execute once at application startup .
Collect the model rules to execute.
Calculate the next execution time. For this we need to store the last execution time so I used the RuleScheduleStorage BO class found at the end of the next snippet
Periodically schedule parallel calls to the PurgeObjects method for each rule.

    public class PurgingController:Controller,IModelExtender{
        protected override void OnFrameAssigned(){
            base.OnFrameAssigned();
            //1.execute once at application startup .
            if (Frame.Context == TemplateContext.ApplicationWindow){
                //2.collect the model rules to execute.
                var purgingRules = Application.Model.BOModel.Cast<IModelClassPurgingRules>().SelectMany(rules => rules.PurgingRules ).ToArray();
                IEnumerable<(IModelPurgingRule rule, DateTime executed)> ruleExecutionTimes;
                //create an objectspace to query the last execution time from the database
                using (var objectSpace = Application.CreateObjectSpace(typeof(RuleScheduleStorage))){

                    DeleteObsoleteRules(objectSpace, purgingRules);
                    var rulesToSchedule = purgingRules.Where(rule =>rule.Interval!=TimeSpan.MinValue);
                    //get an enumerable of (IModelPurgingRule rule, DateTime executed)
                    ruleExecutionTimes = CalculateExecutionTimes(rulesToSchedule, objectSpace);
                }

                foreach (var ruleExecutionTime in ruleExecutionTimes){
                    var timeSinceLastExecution = DateTime.Now.Subtract(ruleExecutionTime.executed);
                    //calculate if periodic task should start with a delay based time passed since last execution
                    int delay=timeSinceLastExecution<ruleExecutionTime.rule.Interval?(int) ruleExecutionTime.rule.Interval.Subtract(timeSinceLastExecution).TotalMilliseconds:0;
                    //starts the task periodically
                    Task.Factory.StartNewPeriodic(() => PurgeObjects(ruleExecutionTime.rule),
                        interval: (int) ruleExecutionTime.rule.Interval.TotalMilliseconds, delay: delay);
                }
            }
        }

        private static IEnumerable<(IModelPurgingRule rule, DateTime executed)> CalculateExecutionTimes(IEnumerable<IModelPurgingRule> rulesToSchedule, IObjectSpace objectSpace){
            return rulesToSchedule.Select(rule => {
                var ruleScheduleStorage = objectSpace.GetObjectsQuery<RuleScheduleStorage>()
                                              .FirstOrDefault(storage =>storage.RuleScheduleType == RuleScheduleType.Purging && storage.RuleId ==((ModelNode) rule).Id);
                return (rule:rule,executed:ruleScheduleStorage?.Executed ?? DateTime.MinValue);
            });
        }

        private void DeleteObsoleteRules(IObjectSpace objectSpace, IModelPurgingRule[] purgingRules){
            var ids = purgingRules.Cast<ModelNode>().Select(node => node.Id).ToArray();
            var rulesToDelete = objectSpace.GetObjectsQuery<RuleScheduleStorage>().Where(storage =>
                storage.RuleScheduleType == RuleScheduleType.Purging && !ids.Contains(storage.RuleId)).ToArray();
            objectSpace.Delete(rulesToDelete);
            objectSpace.CommitChanges();
        }

You might wonder why I inherit from a controller and used the OnFrameAssigned method as start signal and not simply write my code at Application.SetupComplete.Event. The reason for this is that I like to keep my implementation in separate files and not pollute the Module.cs.

The Long Running PurgeObjects method:

Stores last execution time in the database.
Deletes filtered objects in chunks.

        private void PurgeObjects(IModelPurgingRule purgingRule){
            try{
                Tracing.Tracer.LogVerboseText($"Purging {purgingRule}");
                var objectsCount = 0;
                using (var objectSpace = Application.CreateObjectSpace(purgingRule.TypeInfo.Type)){
                    StoreExecutionTime(purgingRule, objectSpace);
                    var criteriaOperator = objectSpace.ParseCriteria(purgingRule.Criteria);
                    var objects = objectSpace.GetObjects(purgingRule.TypeInfo.Type, criteriaOperator);
                    objectSpace.SetTopReturnedObjectsCount(objects, purgingRule.ChunkSize);
                    while (objects.Count > 0){
                        objectsCount += objects.Count;
                        objectSpace.Delete(objects);
                        objectSpace.CommitChanges();
                        objectSpace.ReloadCollection(objects);
                    }                    
                }
                Tracing.Tracer.LogVerboseText($"Purged {purgingRule}-{objectsCount}");
            }
            catch (Exception e){
                Tracing.Tracer.LogError(e);
            }
        }

        private static void StoreExecutionTime(IModelPurgingRule purgingRule, IObjectSpace objectSpace){
            var ruleId = ((ModelNode) purgingRule).Id;
            var ruleScheduleStorage =objectSpace.GetObjectsQuery<RuleScheduleStorage>().FirstOrDefault(storage =>
                    storage.RuleScheduleType == RuleScheduleType.Purging && storage.RuleId == ruleId) ?? objectSpace.CreateObject<RuleScheduleStorage>();
            ruleScheduleStorage.RuleScheduleType = RuleScheduleType.Purging;
            ruleScheduleStorage.RuleId = ((ModelNode) purgingRule).Id;
            ruleScheduleStorage.Executed = DateTime.Now;
            objectSpace.CommitChanges();
        }

Last minute feature

I am happy with the PurgingRules, but I would be more happy if I could invalidate them based on a CSharp expression. For example I want to have some rules on my dev machine only.
The PurgingRules already have a criterion so we could create a Custom Function to evaluate CSharp expressions.
I want to use this code in eXpandFramework which there is a <=.NET4 dependency so for evaluating CSharp expressions I chose compile on the fly + caching the from ExpressionEvaluator.Eval method.

    public class EvaluateExpressionOperator:ICustomFunctionOperator{
        public List<string> Usings=new List<string>();

        public const string OperatorName = "EvaluateExpression";

        public static EvaluateExpressionOperator Instance{ get; } = new EvaluateExpressionOperator();

        public Type ResultType(params Type[] operands){
            return typeof(object);
        }

        public object Evaluate(params object[] operands){
            var csCode = string.Join("",operands);
            var usings = string.Join(Environment.NewLine,Usings);
            var eval = ExpressionEvaluator.Eval(csCode, usings);
            return eval;
        }

        public string Name => OperatorName;
    }

Working with such rich libraries like DevExpress XAF suite you make serious stuff in no time!