Singleton State vs. Singleton Event

Question

I have a Blazor Server App. This app is connected to a SQL DB and is at this time relatively complex. Since the main focus is usability, we ran into some problems when we access the database directly (components not updated correctly, etc.).

Therefore, I am trying to create a StateService which basically acts as some sort of "Cache". Data is stored in it and components can access it, without any loading times. During my research, I had some questions, which the documentation couldn't answer to me.

---

The Problem

It should be possible that all components always have the latest state of the data. This means that clients need to be automatically notified of any changes and automatically refresh their states. It also should be possible to have the power to provide the service to ~1.000 concurrent users, without the necessity to upgrade to a high-end server (I know, that this is very vague).

---

Possible Solutions

Singleton State

I basically have a service, which holds the data as a property in it and has an OnChange-event. Whenever any data property gets set, the event gets triggered. This service is then used by components to display data. When I add data to the database, the data will then be automatically loaded back into the state. I added this service as a singleton, so there is only one object during the server runtime.

public class SharedStateService
{
    public event Action OnChange;
    private ICollection<MyData>? myData;

    public ICollection<MyData>? MyData
    {
        get => this.myData;
        set
        {
            this.myData= value;
            this.OnChange?.Invoke();
        }
    }
}

public class MyDataService
{
    private readonly SharedStateService sharedStateService;
    private readonly TestDbContext context;

    public MyDataService(TestDbContext context, SharedStateService sharedService)
    {
        this.context = context;
        this.sharedStateService = sharedService;
    }

    public async Task<bool> DeleteData(MyData data)
    {
        try
        {
            this.context.Set<MyData>().Remove(data);
            await this.context.SaveChangesAsync();
        }
        catch (Exception)
        {
            return false;
        }

        await this.ReloadData();
        return true;
    }

    public async Task ReloadData()
    {
        this.sharedStateService.MyData =
            await this.context.Set<MyData>().ToListAsync();
    }
}

In my views, it is now possible to subscribe to the OnChange event and freely use the MyData property.

<table class="table">
    <thead>
        <tr>
            <!-- ... -->
        </tr>
    </thead>
    <tbody>
    @foreach (var data in SharedStateService.MyData)
    {
        <tr>
            <!-- ... -->
        </tr>
    }
    </tbody>
</table>

@code {
    public void Dispose()
    {
        SharedStateService.OnChange -= Refresh;
    }

    protected override void OnInitialized()
    {
        SharedStateService.OnChange += Refresh;
    }

    private async void Refresh()
    {
        await InvokeAsync(this.StateHasChanged);
    }
}

The problem I see with this case is that the entire data is constantly stored on the server. Might there be any problems? Am I overthinking it too much? What could possible risks of such an approach be?

Singleton Event

It is similar to the singleton state, but I do not store the data anywhere. Instead of the state, I have a service, which only provides an event, which can be subscribed to. This service is, again, added as a singleton.

public class RefreshService
{
    public event Action OnChange;

    public void Refresh()
    {
        OnChange?.Invoke();
    }
}

This service is then injected into the data providers and called, when a change occur. I extend the MyDataService by a new method.

public async Task<ICollection<MyData>> GetAll()
{
    return await this.context.Set<MyData>().ToListAsync();
}

Afterwards, in my view, I add a property and adjust the Refresh method, to load the data into this local property.

private async void Refresh()
{
    this.MyData= await MyDataService.GetAll();
    await InvokeAsync(this.StateHasChanged);
}

This approach is very similar to the first one, but I don't need to store the data constantly. Is this approach easier to handle for the server? Could this lead to wrong data displayed, since the data is stored redundantly?

---

I know that this is a long read, but maybe someone knows which approach is generally preferable over the other.

Answer 1

Listen to data change it's not a bad idea, the only think i would get focus on it's the way you delete and change. First i will improve on use EFCoreBulkExtensions just for performance, if you will be updating / deleting data everytime, it's not a bad idea to perform that (principally because your database will grow as time goes by).

And what i think it's the proper solution it's the second one, Singleton Event , that way allow's you to prevent the possible error that could make the first one. Think in this scenario: you have 1000 users, it's probably that most of your users where interacting with the data at same time. If you delete, and then refresh the data could make data inconsistency, but if you get the event change state, you could use it as a flag, that data needs to be updated before user interacts with it.

Finally, i think you could use BulkInsertOrUpdateOrDelete method, so if data doesn't exists (with their id), you insert it, if any changes, it get's updates, and if it doesn't exists (an existing id) you delete it, all with one optimized method of bulk extensions. And in case you can't add another library, you should make your own add/update/delete method!