how to correctly subscribe to an ComputedState<T> state value without inheriting from ComputedStateComponent<T>?

[neozhu]

@alexyakunin

Could you please provide me with an example?

I was trying and failing

public class OnlineUserTracker : IOnlineUserTracker
{

    private readonly ConcurrentDictionary<string, UserInfo> _store = new();
    public async Task AddUser(string sessionId, UserInfo userInfo, CancellationToken cancellationToken = default)
    {
        if (Invalidation.IsActive)
            return;
        if (_store.TryAdd(sessionId, userInfo))
        {
            using var invalidating = Invalidation.Begin();
            _ = await GetOnlineUsers(cancellationToken);
        }
    }
    public async Task UpdateUser(UserInfo userInfo, CancellationToken cancellationToken = default)
    {
        if (Invalidation.IsActive)
            return;
        var invalidate = false;
        foreach (var key in _store.Keys)
        {
            if (_store[key].Id == userInfo.Id)
            {
                var updated = _store.TryUpdate(key, userInfo, _store[key]);
                if (invalidate == false)
                {
                    invalidate = updated;
                }
            }
        }
        if (invalidate)
        {
            using var invalidating = Invalidation.Begin();
            _ = await GetOnlineUsers(cancellationToken);
        }
       

    }
    public virtual Task<UserInfo[]> GetOnlineUsers(CancellationToken cancellationToken = default)
    {
        if (Invalidation.IsActive)
            return default!;
        return Task.FromResult(_store.Select(x => x.Value).Distinct(new UserInfoEqualityComparer()).ToArray());
    }

    public async Task RemoveUser(string sessionId, CancellationToken cancellationToken = default)
    {
        if (Invalidation.IsActive)
            return;
        var removed = _store.TryRemove(sessionId, out var userInfo);
        if (removed)
        {
            using var invalidating = Invalidation.Begin();
            await GetOnlineUsers(cancellationToken);
        }
    }
}

 _computed =await ActualLab.Fusion.Computed.Capture(() => OnlineUserTracker.GetOnlineUsers());
 _computed.Invalidated += StateOnStateChanged;

 private void StateOnStateChanged(ActualLab.Fusion.IComputed v)
 {
     
     InvokeAsync(async() => { StateHasChanged(); 
         _computed.Invalidate();
         _computed = await _computed.Update();
     });
    
 }

[alexyakunin]

@neozhu hi, is this still actual? Are you on Fusion's Discord?

[alexyakunin]

Sorry, I just noticed this issue - just so you know, it's better to notify me on Discord - even if you create an issue here.

[alexyakunin]

Ok, now about your code: the easiest way to achieve what you intend to achieve is: https://github.com/ActualLab/Fusion/blob/master/samples/TodoApp/ConsoleClient/Program.cs#L11C1-L14C2

You can use the same approach with IState as well - i.e. it also has .Changes extension method. I also recommend you to look at the code of this method to learn how it works.

[neozhu]

Thank you for your response.
This seems correct, but I found that it doesn't seem to subscribe to data change events.

private Computed<UserInfo[]> computed;
private Action<IComputed> invalidatedHandler;
protected override async Task OnInitializedAsync()
{
  
    computed = await Computed.Capture(() => OnlineUserTracker.GetOnlineUsers());
    invalidatedHandler = async (IComputed c) => await OnInvalidated(c);
    computed.Invalidated += invalidatedHandler;

}
private  async Task OnInvalidated(IComputed state)
{
    await InvokeAsync(StateHasChanged);
}
public void Dispose()
{
    computed.Invalidated -= invalidatedHandler;
}