Long delay in Blazor after saving model and the page updating.

[adrianwright109]

Hi,

I have a BusinessBase editable object which has 16 properties on it that are updated from the Blazor UI.

When I save the object using Clsa.Blazor.ViewModel.SaveAsync() method it saves as expected in a timing manner.

The SaveAsync() implementation in Csla.Blazor.ViewModel has these 2 lines:

Model = await DoSaveAsync();
Saved?.Invoke();

In my example it takes over 4.5 minutes from the DoSaveAsync() call for the Saved action to be invoked. I'm not sure why this is happening?

I have a theory that it might be data related...

So I lied... my business editable object has 2 additional properties to maintain a 2 different lists of string. Only holds database field names and the other holds a list of unique record keys.

The reason for this is that we have a legacy stored procedure to call just after updating the repository with the updated editable object. This SP takes in a comma separated list of database field names and a comma separated list of unique record IDs.

I'm my scenario I have a list of 16 database field names and a list of 714 record IDs.

These 2 properties have been implemented using a BusinessListBase parent list with BusinessBase children. This allows for us to add items to the list in the UI prior to saving.

It seems to me that the 4.5 minutes is spent checking the model include these 2 properties to see what model values have changed.

Should I be using a more lightweight approach as these lists don't have any business rules; they are purely there to store the values so we can send them as a comma separated list to the stored procedure?

public static readonly PropertyInfo<MetaEditList> ForceFieldListProperty = RegisterProperty<MetaEditList>(nameof(ForceFieldList));
public MetaEditList ForceFieldList
{
    get => GetProperty(ForceFieldListProperty);
    set => SetProperty(ForceFieldListProperty, value);
 }

public static readonly PropertyInfo<MetaEditList> RecordKeyListProperty = RegisterProperty<MetaEditList>(nameof(RecordKeyList));
public MetaEditList RecordKeyList
 {
    get => GetProperty(RecordKeyListProperty);
    set => SetProperty(RecordKeyListProperty, value);
}

The parent list class:

    [Serializable]
    public class MetaEditList : BusinessListBase<MetaEditList, MetaEdit>
    {
        public static MetaEdit AddMeta(string value)
        {
            return DataPortal.Create<MetaEdit>(value);
        }

        [Create]
        private async Task Create(string csvList)
        {
            using (LoadListMode)
            {
                var list = csvList.Split(",");
                var data = list.Select(d => DataPortal.CreateChild<MetaEdit>(d));
                AddRange(data);
            }
        }

        [Fetch]
        private async Task Fetch()
        {
            using (LoadListMode)
            {
            }
        }

        [Update]
#pragma warning disable 1998
        private async Task Update()
#pragma warning restore 1998
        {
            using (LoadListMode)
            {
                Child_Update();
            }
        }

    }

The parent list child item class:

    [Serializable]
    public class MetaEdit : BusinessBase<MetaEdit>
    {
        public MetaEdit()
        {
            MarkAsChild();
        }

        public static readonly PropertyInfo<string> MetaValueProperty = RegisterProperty<string>(propertyName: nameof(MetaValue));
        public string MetaValue
        {
            get => GetProperty(MetaValueProperty);
            set => LoadProperty(MetaValueProperty, value);
        }

        protected override void AddBusinessRules()
        {
            base.AddBusinessRules();

            BusinessRules.AddDataAnnotations();
        }

        [ObjectAuthorizationRules]
        public static void AddObjectAuthorizationRules()
        {
        }

        [CreateChild]
        private void Create()
        {
        }

        [CreateChild]
        private void Create(string value)
        {
            using (BypassPropertyChecks)
            {
                MetaValue = value;
            }
        }

        [FetchChild]
#pragma warning disable 1998
        private async Task Fetch()
        {
        }

        [InsertChild]
        private void Insert()
        {
        }

        [UpdateChild]
        private void Update()
        {
        }

        [DeleteSelfChild]
        private void DeleteSelf()
        {
        }

        [DeleteSelfChild]
        private void Delete()
        {
        }
    }

[adrianwright109]

Seems to be spending a lot of time (1200 times - gave up counting after that!!) in the below method on the Blazor component for (IsDirty, IsSavable etc) after the save has completed and before Saved event is invoked:

        private async Task OnModelPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            await InvokeAsync(StateHasChanged);
        }

[rockfordlhotka]

Sounds like an event loop occurring - where the UI refresh from StateHasChanged is triggering 1+ property changes in the model, thus causing PropertyChanged events.