Reflection only successful on first call in Blazor-State-Management

Question

I discovered a weird behavior where I absolutely don't know where it comes from or how to fix it. The issue arises with the blazor-state management (which is based on the mediator pattern) - library can be found here: https://timewarpengineering.github.io/blazor-state/.

Lets assume we have the following base class for an enumeration:

public abstract class Simple<TSimple> where TSimple: Simple<TSimple>
{
    private readonly string _key;

    protected Simple(string key)
    {
        _key = key;
    }

    public virtual string Key => _key;

    public static TSimple Create(string key)
    {
        var obj = All.SingleOrDefault(e => e.Key == key);
        return obj;
    }

    public static IReadOnlyCollection<TSimple> All => GetAll();

    private static IReadOnlyCollection<TSimple> GetAll()
    {
        var enumerationType = typeof(TSimple);

        return enumerationType.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)
            .Where(info => enumerationType.IsAssignableFrom(info.FieldType))
            .Select(info => info.GetValue(null))
            .Cast<TSimple>()
            .ToArray();
    }
}

And the following enumeration implementation:

public class SimpleImpl : Simple<SimpleImpl>
{
    public static readonly SimpleImpl One = new SimpleImpl("Important");
    public static readonly SimpleImpl Two = new SimpleImpl("Urgent");
    public static readonly SimpleImpl Three = new SimpleImpl("ImportantAndUrgent");
    public static readonly SimpleImpl Four = new SimpleImpl("None");

    private SimpleImpl(string key) : base(key)
    {
    }
}

So far so good. I use this enumeration in a blazor app, where the data is retrieved via gRPC-Web from the backend, is transformed and added to the state.

So the code section of the Index.cshtml looks something like this:

@code
{
    private AppState AppState => GetState<AppState>();

    protected override async Task OnInitializedAsync()
    {
        foreach (var simple in new[] {"Important", "Urgent", "ImportantAndUrgent", "None"})
    {
        await Mediator.Send(new AppState.AddAction(simple));
    }
}

This gets handled by the Handler:

public partial class AppState
{
    public class AppHandler : ActionHandler<AddAction>
    {
        private AppState AppState => Store.GetState<AppState>();

        public AppHandler(IStore store) : base(store)
        {
        }

        public override async Task<Unit> Handle(AddAction aAction, CancellationToken aCancellationToken)
        {
            var simple = SimpleImpl.Create(aAction.Simple);
            Console.WriteLine(simple == null); // First call false, afterwards true
            AppState.Simples.Add(simple); // If I don't add the object to the state, Simple.Create always returns an object
            return await Unit.Task;
        }
    }
}

And here is the problem. On the first try everything works, but if the functions gets called a second time (so my gRPC-Client returns multiple items) simple will always be null. If I remove the AppState.Simples.Add(simple) then it works again. If I add the following code: Console.WriteLine(string.Join(",", SimpleImpl.All.Select(s => s.Key)); on the first run it prints all the possible values:

Important,Urgent,ImportantAndUrgent,None

On the second run, this:

,Urgent,,

Urgent was in the Dto in the first run. So it seems something to do with how the reference in the List is kept alive (which should not interfer with how the reflection part in Simple works).

Furthermore: in the GetAll() function of Simple everything works fine until the Select(info => .GetValue(null)) The FieldInfo-Property itself holds all 4 options. After GetValue and the cast there is only the last choosen one "alive".

The State-Entity looks like the following:

public partial class AppState : State<AppState>
{
    public IList<SimpleImpl> Simples { get; private set; }

    public override void Initialize()
    {
        Simples = new List<SimpleImpl>();
    }
}

And the Action of this sample:

public partial class AppState
{
    public class AddAction : IAction
    {
        public AddAction(string simple)
        {
            Simple = simple;
        }

        public string Simple { get; }
    }
}

This code is running under .NET Core 3.1. If anybody has a tip where the problem lays I would be very thankful.

Answer 1

Thanks to @steven-t-cramer how helped me on finding the issue. Basically it all boils down to the Mediator.Send and State-Handling.

In the Blazor-State library a clone is created when one dispatches and handles an action (so you as a developer don't have to take care of that). But exactly this cloning messed up big time here because of the static nature of Simple(basically an enumeration class).

To get around that, the state can implement ICloneable and do this stuff on its own.

A very naive way to do would be that:

public partial class AppState : State<AppState>, ICloneable
{
    private List<SimpleImpl> _simples = new List<SimpleImpl>();

    public IReadOnlyList<SimpleImpl> Simples => _simples.AsReadOnly();

    public override void Initialize()
    {
        _simples = new List<SimpleImpl>();
    }

    public object Clone()
    {
        var state = new AppState { _simples = _simples};
        return state;
    }
}