Clean Architecture Domain Data Bindings

[LSXAxeller]

I am rebuilding my app using clean architecture with Avalonia for cross-platform support. I'm trying to follow the SOLID principles, but I've encountered some issues. The UI doesn't update after editing entities' properties like Name or Email; it only reflects changes when data is populated or when items are added or removed from the list, but the edited properties still same.

I am trying to bind domain entities/models from the application layer without wrappers or custom view model per entity, in theory it should work, I am getting the output console messages correctly and I don't see the problem, I didn't use INotifyPropertyChanged or ReactiveObject in Domain since I want to keep it clean and independent from UI components and External libraries.

Domain Layer

using System.Runtime.CompilerServices;

namespace CleanArchitectureUI.Domain.Interfaces;

public interface ISignalNotifier
{
    void Notify(string propertyName);
    void Notify<T>(ref T backingField, T newValue, [CallerMemberName] string? propertyName = null);
}

using System.Diagnostics;
using System.Runtime.CompilerServices;
using CleanArchitectureUI.Domain.Interfaces;

namespace CleanArchitectureUI.Domain.Services;

public class SignalNotifier : ISignalNotifier
{
    public static SignalNotifier Instance => _instance;
    private static SignalNotifier _instance;

    private readonly ISignalNotifier _signalNotifier;

    public SignalNotifier(ISignalNotifier signalNotifier)
    {
        _instance = this;
        _signalNotifier = signalNotifier;
        Debug.WriteLine($"SignalNotifier created of type: {_signalNotifier.GetType()}");
    }

    public void Notify(string propertyName)
    {
        _signalNotifier.Notify(propertyName);
    }
    public void Notify<T>(ref T backingField, T newValue, [CallerMemberName] string? propertyName = null)
    {
        _signalNotifier.Notify(ref backingField, newValue, propertyName);
    }
}

using System.Runtime.CompilerServices;
using CleanArchitectureUI.Domain.Services;

namespace CleanArchitectureUI.Domain.Entities;

public abstract class BaseEntity
{
    public void Notify(string propertyName) => SignalNotifier.Instance?.Notify(propertyName);
    public void Notify<T>(ref T backingField, T newValue, [CallerMemberName] string? propertyName = null) => SignalNotifier.Instance?.Notify(ref backingField, newValue, propertyName);
}

namespace CleanArchitectureUI.Domain.Entities;

public class User : BaseEntity
{
    public int _id;
    public int Id
    {
        get => _id;
        set
        {
            _id = value;
            Notify(ref _id, value);
        }
    }

    private string _name;
    public string Name
    {
        get => _name;
        set
        {
            _name = value;
            Notify(ref _name, value); // SignalNotifier of Reactive: CleanArchitectureUI.Presentation.Services.UINotifier, reacted to: Name
        }
    }

    private string _email;
    public string Email
    {
        get => _email;
        set
        {
            _email = value;
            Notify(nameof(Email)); // SignalNotifier of type: CleanArchitectureUI.Presentation.Services.UINotifier, reacted to: Email
        }
    }
}

and Injecting this from presentation layer (AvaloniaUI) into the SignalNotifier as private readonly ISignalNotifier _signalNotifier; successfully, tried using both of Notify(string propertyName) and public void Notify<T>(ref T backingField, T newValue, [CallerMemberName] string? propertyName = null) but no luck

Presentation Layer

using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using CleanArchitectureUI.Domain.Interfaces;
using ReactiveUI;

namespace CleanArchitectureUI.Presentation.Services;

public class UINotifier : ReactiveObject, ISignalNotifier, INotifyPropertyChanged
{
    public void Notify(string propertyName)
    {
        Debug.WriteLine($"SignalNotifier of type: {GetType()}, reacted to: {propertyName}");
        OnPropertyChanged(propertyName);
    }

    public void Notify<T>(ref T backingField, T newValue, [CallerMemberName] string? propertyName = null)
    {
        Debug.WriteLine($"SignalNotifier of Reactive: {GetType()}, reacted to: {propertyName}");
        this.RaiseAndSetIfChanged(ref backingField, newValue, propertyName);
    }


    public new event PropertyChangedEventHandler? PropertyChanged;
    public void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

}

var services = new ServiceCollection()
    .AddSingleton<ISignalNotifier, UINotifier>()
    .AddSingleton<SignalNotifier>()
    .BuildServiceProvider()
    .GetService<SignalNotifier>(); // to setup singleton `Instance` with UINotifier as _signalNotifier

<ListBox Grid.Row="1" ItemsSource="{Binding Users}" SelectedItem="{Binding CurrentUser}" Margin="25">
    <ListBox.ItemTemplate>
        <DataTemplate>
            <StackPanel Orientation="Horizontal">
                <TextBox Text="{Binding Id}" IsReadOnly="True" />
                <TextBox Text="{Binding Name, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
                <TextBlock Text="{Binding Name}" Margin="5" />
                <TextBox Text="{Binding Email}" />
            </StackPanel>
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

[timunie]

Avalonia requires INotifyPropertyChanged, not that signal stuff. Check Avalonia.Samples MVVM samples.

[stevemonaco]

In-memory domains with their own synchronization are hard to do correctly and yours ends up not being MVVM at all. If you're binding UI inputs to domain objects (either directly or using instant synchronization), you are necessarily putting your domain objects into an invalid state. This isn't acceptable to me. The ViewModel exists as a temporary, editable copy of some domain state, valid or not. So you need some way to suspend synchronization until validation can be performed on the entire object.

Avalonia can bind to observables, so I would probably try that instead of this custom implementation + adapter. You can't raise INPC for a different object instance, AFAIK, but I could be wrong there.

[LSXAxeller]

I just found that using System.ComponentModel and NotifyPropertyChanged in Domain isn't a UI code so it doesn't violate the concern of separation principles, I just did this and it's working

using System.ComponentModel;
using System.Runtime.CompilerServices;

namespace CleanArchitectureUI.Domain.Entities;

public abstract class BaseEntity : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler? PropertyChanged;
    public void OnPropertyChanged(string propertyName) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    public void Notify<T>(ref T field, T value, [CallerMemberName] string? propertyName = null)
    {
        field = value;
        OnPropertyChanged(propertyName);
    }
}



namespace CleanArchitectureUI.Domain.Entities;

public class User : BaseEntity
{
    private int _id;
    public int Id
    {
        get => _id;
        set => Notify(ref _id, value);
    }

    private string _name = string.Empty;
    public string Name
    {
        get => _name;
        set => Notify(ref _name, value);
    }

    private string _email = string.Empty;
    public string Email
    {
        get => _email;
        set => Notify(ref _email, value);
    }
}

[stevemonaco]

You should check value equality in Notify otherwise you can trigger re-entrant updates when two properties are synchronized leading to a StackOverflowException. It also saves some updates.

[LSXAxeller]

Thank you for pointing this out, I added it

public void Notify<T>(ref T field, T value, [CallerMemberName] string? propertyName = null)
{
    if (EqualityComparer<T>.Default.Equals(field, value)) return;

    field = value;
    OnPropertyChanged(propertyName!);
}