CSLA Fails When Invoking a Blazor Page with Parameters

[ecaldentey]

Hi Rocky,

For some reason, when I invoke a Blazor page passing parameters, CSLA throws an error. If I invoke the page without passing a parameter, everything works fine.

@page "/NewContract"
@page "/NewContract/{dealType}"

When I invoke the page with the following code:
NavLink href="/NewContract/Contract" class="nav-link"

Csla throws an error when fetching objects.

If I invoke it with the following code:
NavLink href="/NewContract" class="nav-link"

Everything works fine.

The error occurs in the OnAfterRenderAsync method when fetching the objects.

protected override async Task OnAfterRenderAsync(bool firstRender)
{
if (firstRender)
{
await StateManager.InitializeAsync();

    // ...

    var customerList = await dataportal.GetAsync(customerFilter); **<= Error**

    StateHasChanged();
}

}

The GetAsync method executes fine, and the flow moves to the DataPortal side where the Fetch method is executed. However, upon exiting the Fetch method, an error is generated.

[Fetch]
private void Fetch(CustomerInfo.FilterCriteria filterCriteria, [Inject] ICustomerDal dal, [Inject] IChildDataPortal dataPortal)
{
try
{
#region [TryFetchData]

    IsReadOnly = false;

    CustomerDto customerDto = new CustomerDto();

    Csla.Data.DataMapper.Map(filterCriteria, customerDto, true);

    var data = dal.FetchList(customerDto, (CustomerSelectDbTypes)(filterCriteria.OptionSelector ?? CustomerSelectDbTypes.SelectAll), filterCriteria.CustomFilters).Select(d => dataPortal.FetchChild(filterCriteria, d));

    this.AddRange(data);

    IsReadOnly = true;
    // ...
} **<= Error**

}

If the page is called without passing parameters, everything works fine.

What could be causing the error?

[ecaldentey]

I added a try-catch block around the code

try
{
var customerList = await dataportal.GetAsync(customerFilter);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}

The error message is:

"Cannot access a disposed object. Object name: 'IServiceProvider'."

However, if the page doesn't receive parameters, the fetch is executed perfectly.

[StefanOssendorf]

Can you provide some sample code to illustrate that?
I'm not using Blazor but it should work with sync on the server side. The client side though will be async because of blazor (blocking is bad in that case).

[rockfordlhotka]

The server-side data portal does invoke methods that return Task in an async manner, and methods that return void in a sync manner.

This doesn't really impact most calling client-side code except in some rare cases (in Windows Forms and console apps iirc).

The client-side data portal can be async and the server-side methods be sync or async and it doesn't matter (shouldn't matter).

[lwmorris067]

I'm pretty sure the root cause isn't CSLA, rather basic use of async/Task operations.

I created a new Blazor Web App just like below, but didn't do any CSLA related stuff. I just changed Weather.razor.

    protected override async Task OnInitializedAsync()
    {
        // Simulate asynchronous loading to demonstrate a loading indicator
        await FetchAsync();
    }

    private Task FetchAsync()
    {
        Fetch();
        return Task.CompletedTask;
    }

    private async void Fetch()
    {
        await Task.Delay(new TimeSpan(0,0,10));

        var startDate = DateOnly.FromDateTime(DateTime.Now);
        var summaries = new[] { "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching" };
        forecasts = Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = startDate.AddDays(index),
                TemperatureC = Random.Shared.Next(-20, 55),
                Summary = summaries[Random.Shared.Next(summaries.Length)]
            }).ToArray();
    }

The moment it hits await Task.Delay(), control returns to FetchAsync and proceeds on. Make the following changes to the above code and things will work like you think.

 private async Task FetchAsync()
    {
        await Fetch();
    }

    private async Task Fetch()...

This isn't exactly what's happening with CSLA, but it is :)

Original post below

Steps to reproduce the issue:

1. Create a Blazor Web App with:
   • Framework = .Net 8.0
   • Authentication type = None
   • Configure for Https = checked
   • Interactive render mode = server
   • Interactivity location = Global
   • Include Sample pages = checked
   • Do not use top-level statements = not checked
   • Enlist in .NET Aspire orchistration = not checked
2. Add Nuget Packages
   • Csla.AspNetCore 8.2.7
   • Csla.Blazor 8.2.7
3. Update program.cs

using BlazorApp4.Components;
using Csla.Configuration;
using Microsoft.AspNetCore.Server.Kestrel.Core;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

builder.Services.AddControllers(); 
builder.Services.AddHttpContextAccessor();

builder.Services.AddCsla(o => o
  .AddAspNetCore()
  .AddServerSideBlazor(o => o.UseInMemoryApplicationContextManager = true)
  .Security(so => so.FlowSecurityPrincipalFromClient = true)
  .DataPortal(dpo => dpo
    .AddServerSideDataPortal()));

builder.Services.Configure<KestrelServerOptions>(options =>
{
    options.AllowSynchronousIO = true;
});

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error", createScopeForErrors: true);
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}

app.MapControllers();

app.UseHttpsRedirection();

app.UseStaticFiles();
app.UseAntiforgery();

app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode();

app.Run();

1. Create a class named ForecastList.cs in the Pages folder.

using Csla;

namespace BlazorApp4.Components.Pages
{
    [Serializable]
    public class ForecastList : BusinessListBase<ForecastList, ForcastListItem>
    {
        [Fetch]
        private async void Fetch()
        {
            using (LoadListMode)
            {
                await Task.Delay(new TimeSpan(0,0,15));

                var startDate = DateOnly.FromDateTime(DateTime.Now);
                var summaries = new[] { "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching" };
                for (int i = 1; i < 6; i++)
                {
                    var item = this.AddNew();
                    item.Date = startDate.AddDays(i);
                    item.TemperatureC = Random.Shared.Next(-20, 55);
                    item.Summary = summaries[Random.Shared.Next(summaries.Length)];
                }
            }
        }
    }

    [Serializable]
    public class ForcastListItem : BusinessBase<ForcastListItem>
    {
        public static readonly PropertyInfo<DateOnly> DateProperty = RegisterProperty<DateOnly>(nameof(Date));
        public DateOnly Date
        {
            get => GetProperty(DateProperty);
            set => SetProperty(DateProperty, value);
        }

        public static readonly PropertyInfo<int> TemperatureCProperty = RegisterProperty<int>(nameof(TemperatureC));
        public int TemperatureC
        {
            get => GetProperty(TemperatureCProperty);
            set => SetProperty(TemperatureCProperty, value);
        }

        public static readonly PropertyInfo<int> TemperatureFProperty = RegisterProperty<int>(nameof(TemperatureF));
        public int TemperatureF
        {
            get => GetProperty(TemperatureFProperty);
        }

        public static readonly PropertyInfo<string> SummaryProperty = RegisterProperty<string>(nameof(Summary));
        public string Summary
        {
            get => GetProperty(SummaryProperty);
            set => SetProperty(SummaryProperty, value);
        }

        [Create]
        public void Create()
        {
            BusinessRules.CheckRules();
        }
    }
}

1. Create a class named ConvertToFRule.cs

using Csla.Core;
using Csla.Rules;

namespace BlazorApp4.Components.Pages
{
    public class ConvertToFRule : BusinessRule
    {
        public ConvertToFRule(IPropertyInfo celsiusProperty, IPropertyInfo ferinheightProperty) : base(celsiusProperty)
        {
            InputProperties.Add(celsiusProperty);
            AffectedProperties.Add(ferinheightProperty);
        }

        protected override void Execute(IRuleContext context)
        {
            var c = context.GetInputValue<int>(PrimaryProperty);

            context.AddOutValue(AffectedProperties[1], 32 + (int)(c / 0.5556));

            base.Execute(context);
        }
    }
}

1. Change Weather.razor

@page "/weather"
@using Csla
@using Csla.Blazor
@inject IDataPortal<ForecastList> DataPortal
@inject ViewModel<ForecastList> DataModel

<PageTitle>Weather</PageTitle>

<h1>Weather</h1>

<p>This component demonstrates showing data.</p>

@if (DataModel.Model == null)
{
    <p><em>Loading...</em></p>
}
else
{
    <table class="table">
        <thead>
            <tr>
                <th>Date</th>
                <th>Temp. (C)</th>
                <th>Temp. (F)</th>
                <th>Summary</th>
            </tr>
        </thead>
        <tbody>
            @foreach (var forecast in DataModel.Model)
            {
                <tr>
                    <td>@forecast.Date.ToShortDateString()</td>
                    <td>@forecast.TemperatureC</td>
                    <td>@forecast.TemperatureF</td>
                    <td>@forecast.Summary</td>
                </tr>
            }
        </tbody>
    </table>
}

@code {
    protected override async Task OnInitializedAsync()
    {
        await DataModel.RefreshAsync(() => DataPortal.FetchAsync());
    }
}

1. Run the app.
2. Click on Weather Forecast
3. Marvel at the empty weather forecast.
4. If you place a breakpoint in forecast.cs just after the await Task.Delay, you will see it break after 15 seconds. Unfortunately, the UI has moved on. If you try doing any dataportal operations or the like, you'll likely see the object disposed exception.

The fix?

1. Change ForecastList.cs. Change private async void Fetch() to private async Task Fetch() and things will work as expected.

[lwmorris067]

Now that I've though a little more about it, I think your idea of eliminating syncronise data portal calls and force all data portal methods to return Task, that will 'fix' the issue above.

[StefanOssendorf]

Yeah your fix is the only fix available for that. As a big rule of thumb: Avoid async void. There are some cases where it's "okay". But the problem with async void is that the calling code does not know the method is still running. The first await hit which causes an async operation will "finish" the method for the caller. Because of that always (99.99%) use async Task whenever possible.

[rockfordlhotka]

What version of CSLA?

We fixed a bug about this at some point if I remember correctly.