c#开发的ref和watch实现--轻松完成响应式开发--

using System;
using System.Collections.Generic;


public class Observable
{
    private readonly Dictionary<string, List<Action<object, object>>> _propertyObservers = new();

    public ObservableProperty<T> Ref<T>(T initialValue, string propertyName)
    {
        return new ObservableProperty<T>(initialValue, this, propertyName);
    }

    public ObservableList<T> RefList<T>(IList<T> initialValue, string propertyName)
    {
        var list = new ObservableList<T>(initialValue, this, propertyName);
        return list;
    }

    public void Watch(string propertyName, Action<object, object> callback)
    {
        if (!_propertyObservers.ContainsKey(propertyName))
        {
            _propertyObservers[propertyName] = new List<Action<object, object>>();
        }

        _propertyObservers[propertyName].Add(callback);
    }

    public void Unwatch(string propertyName, Action<object, object> callback)
    {
        if (_propertyObservers.ContainsKey(propertyName))
        {
            _propertyObservers[propertyName].Remove(callback);
        }
    }

    public void NotifyPropertyChange(string propertyName, object oldValue, object newValue)
    {
        if (_propertyObservers.TryGetValue(propertyName, out var callbacks))
        {
            foreach (var callback in callbacks)
            {
                callback?.Invoke(oldValue, newValue);
            }
        }
    }
}
复制
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;

public class ObservableProperty<T>
{
    private T _value;
    private readonly Observable _observable;
    private readonly string _propertyName;

    public ObservableProperty(T initialValue, Observable observable, string propertyName)
    {
        _value = initialValue;
        _observable = observable;
        _propertyName = propertyName;
    }

    public string PropertyName => _propertyName;

    public T Value
    {
        get => _value;
        set
        {
            if (!EqualityComparer<T>.Default.Equals(_value, value))
            {
                T oldValue = _value;
                _value = value;
                _observable.NotifyPropertyChange(_propertyName, oldValue, value);
            }
        }
    }
}
public class ObservableList<T> : Collection<T>
{
    private readonly Observable _observable;
    private readonly string _propertyName;

    public ObservableList(IList<T> list, Observable observable, string propertyName)
        : base(list)
    {
        _observable = observable;
        _propertyName = propertyName;
    }

    protected override void InsertItem(int index, T item)
    {
        base.InsertItem(index, item);
        NotifyChange();
    }

    protected override void SetItem(int index, T item)
    {
        T oldItem = Items[index];
        base.SetItem(index, item);
        NotifyChange(oldItem, item);
    }

    protected override void RemoveItem(int index)
    {
        T item = Items[index];
        base.RemoveItem(index);
        NotifyChange(item, default(T)); // 使用 default(T) 来代表 null
    }

    protected override void ClearItems()
    {
        var oldItems = Items.ToList(); // 将 Items 转换为 List<T>
        base.ClearItems();
        NotifyChange(oldItems, new List<T>());
    }

    private void NotifyChange(T oldValue, T newValue)
    {
        _observable.NotifyPropertyChange(_propertyName, oldValue, newValue);
    }

    private void NotifyChange()
    {
        _observable.NotifyPropertyChange(_propertyName, null, null);
    }

    private void NotifyChange(List<T> oldValues, List<T> newValues)
    {
        _observable.NotifyPropertyChange(_propertyName, oldValues, newValues);
    }
}

public Observable _observable = new Observable();

    public ObservableProperty<string> Time { get; set; }
       public PlayerCompany()

    {

        Time = _observable.Ref("Initial Time", nameof(Time));

    }

    public ObservableList<Employee> Mangers { get; set; }
    public PlayerCompany()

    {

        Mangers = _observable.RefList(new List<Employee> { null},nameof(Mangers));

    }

 PlayerCompany.Instance._observable.Watch(nameof(PlayerCompany.Time), _timeChangeCallback = (oldValue, newValue) =>
 {

 });