ReactiveUI与CanExecute：如何实现对异步布尔变量的定期校验

因为Socket类没有实现INotifyPropertyChanged接口，无法直接让ReactiveCommand自动感知其状态变化，你可以通过以下几种方案实现定期校验CanExecute逻辑：

方案1：用Observable.Interval定时轮询状态 #

这是最直接的方案，通过定时触发Socket状态检查，将结果转为Observable传给ReactiveCommand。

using System.Reactive.Linq;
using ReactiveUI;
using System.Net.Sockets;

public class YourViewModel : ReactiveObject
{
    private readonly Socket _socket;
    public ReactiveCommand<Unit, Unit> SocketOperationCommand { get; }

    public YourViewModel(Socket socket)
    {
        _socket = socket;

        // 每隔500毫秒执行一次状态检查，可根据需求调整间隔
        var canExecute = Observable.Interval(TimeSpan.FromMilliseconds(500))
            .Select(_ => CheckSocketValidity())
            .DistinctUntilChanged(); // 仅当状态变化时才更新，避免无效重复触发

        SocketOperationCommand = ReactiveCommand.Create(ExecuteSocketOperation, canExecute);
    }

    // 自定义Socket状态校验逻辑
    private bool CheckSocketValidity()
    {
        // 示例：检查Socket是否已连接且非阻塞
        return _socket.Connected && !_socket.Blocking;
    }

    // 命令执行逻辑
    private void ExecuteSocketOperation()
    {
        // 这里写你的Socket操作代码
    }
}

DistinctUntilChanged的作用是过滤重复的状态值，避免按钮IsEnabled属性频繁无意义地更新，优化性能。

方案2：结合Socket事件+定时轮询（更高效） #

如果Socket提供状态变化事件（比如Connected、Disconnected），可以结合事件触发实时检查+定时轮询兜底，既保证实时性又避免遗漏状态变化。

using System.Reactive.Linq;
using ReactiveUI;
using System.Reactive.Subjects;
using System.Net.Sockets;

public class YourViewModel : ReactiveObject, IDisposable
{
    private readonly Socket _socket;
    private readonly Subject<Unit> _socketStateTrigger = new();
    public ReactiveCommand<Unit, Unit> SocketOperationCommand { get; }

    public YourViewModel(Socket socket)
    {
        _socket = socket;

        // 订阅Socket状态事件，触发检查
        _socket.Connected += (s, e) => _socketStateTrigger.OnNext(Unit.Default);
        _socket.Disconnected += (s, e) => _socketStateTrigger.OnNext(Unit.Default);

        // 合并事件触发和定时轮询的检查信号
        var canExecute = Observable.Merge(
                Observable.Interval(TimeSpan.FromMilliseconds(1000)),
                _socketStateTrigger
            )
            .Select(_ => CheckSocketValidity())
            .DistinctUntilChanged();

        SocketOperationCommand = ReactiveCommand.Create(ExecuteSocketOperation, canExecute);
    }

    private bool CheckSocketValidity()
    {
        return _socket.Connected && !_socket.Blocking;
    }

    private void ExecuteSocketOperation()
    {
        // 命令执行逻辑
    }

    public void Dispose()
    {
        _socketStateTrigger.Dispose();
    }
}

这种方式在Socket状态变化时立即更新CanExecute状态，平时用定时轮询防止事件未触发的边缘情况。

方案3：封装Socket为可观察的Wrapper类 #

把Socket包装成实现INotifyPropertyChanged的类，将Socket的属性转为可观察的通知属性，再用ReactiveUI的WhenAnyValue监听状态变化。

using System.ComponentModel;
using System.Net.Sockets;
using System.Timers;
using ReactiveUI;

// Socket包装类
public class SocketWrapper : INotifyPropertyChanged, IDisposable
{
    private readonly Socket _socket;
    private readonly Timer _stateCheckTimer;

    public SocketWrapper(Socket socket)
    {
        _socket = socket;
        // 定时检查并触发属性变更通知
        _stateCheckTimer = new Timer(500) { AutoReset = true };
        _stateCheckTimer.Elapsed += (s, e) =>
        {
            OnPropertyChanged(nameof(Connected));
            OnPropertyChanged(nameof(Blocking));
        };
        _stateCheckTimer.Start();
    }

    // 暴露需要检查的Socket属性
    public bool Connected => _socket.Connected;
    public bool Blocking => _socket.Blocking;

    public event PropertyChangedEventHandler PropertyChanged;

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

    public void Dispose()
    {
        _stateCheckTimer.Dispose();
    }
}

// ViewModel中使用Wrapper
public class YourViewModel : ReactiveObject, IDisposable
{
    private SocketWrapper _socketWrapper;
    public ReactiveCommand<Unit, Unit> SocketOperationCommand { get; }

    public SocketWrapper SocketWrapper
    {
        get => _socketWrapper;
        set => this.RaiseAndSetIfChanged(ref _socketWrapper, value);
    }

    public YourViewModel(Socket socket)
    {
        SocketWrapper = new SocketWrapper(socket);

        // 监听Wrapper的属性变化，生成CanExecute信号
        var canExecute = this.WhenAnyValue(
            vm => vm.SocketWrapper.Connected,
            vm => vm.SocketWrapper.Blocking,
            (connected, blocking) => connected && !blocking
        );

        SocketOperationCommand = ReactiveCommand.Create(ExecuteSocketOperation, canExecute);
    }

    private void ExecuteSocketOperation()
    {
        // 命令执行逻辑
    }

    public void Dispose()
    {
        SocketWrapper.Dispose();
    }
}

这种方案更贴合MVVM模式，将Socket的状态抽象为可观察的ViewModel属性，代码更整洁。

注意事项 #

• 定时间隔根据业务需求调整：间隔过短会增加性能开销，过长会导致状态更新延迟。
• 资源释放：如果使用了Timer或Subject，记得在ViewModel或Wrapper销毁时调用Dispose释放资源，避免内存泄漏。
• Avalonia会自动绑定ReactiveCommand的CanExecute状态到按钮的IsEnabled属性，无需手动设置。

内容的提问来源于stack exchange，提问作者Bob_Foo