1
2
3
4
5
6
7
8
9
10
11
12
13
using ReactiveUI;

public class UserViewModel : ReactiveObject
{
    private string _userName;
    public string UserName
    {
        get => _userName;
        // API: bool RaiseAndSetIfChanged<TObj, TRet>(ref TRet backingField, TRet newValue)
        // 只有值改变才会返回 True，并对外广播 [PropertyChanged] 信号
        set => this.RaiseAndSetIfChanged(ref _userName, value);
    }
}

1
2
3
4
5
6
7
public class UserViewModel : ReactiveObject
{
    // 在编译时，Fody 会全自动将其转化为带 RaiseAndSetIfChanged 的完整形态！
    [Reactive] public string UserName { get; set; }
    [Reactive] public int Age { get; set; }
    [Reactive] public bool IsVip { get; set; }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class LoginViewModel : ReactiveObject
{
    // 第一个参数是输入(TParam)，第二个参数是该任务完成的返回值(TResult)
    public ReactiveCommand<Unit, bool> LoginCmd { get; }

    [Reactive] public string Account { get; set; }
    [Reactive] public string Password { get; set; }

    public LoginViewModel()
    {
        // 构建 IObservable<bool> 控制流，后面章节详细解释 WhenAnyValue
        var isInputValid = this.WhenAnyValue(
            vm => vm.Account,
            vm => vm.Password,
            (acc, pwd) => !string.IsNullOrEmpty(acc) && pwd?.Length >= 6);

        // 绑定流，如果 input 不 valid，命令不可用；并且点击时进入防抖等待
        LoginCmd = ReactiveCommand.CreateFromTask<Unit, bool>(async _ =>
        {
            await Task.Delay(2000); // 假装请求 API 网络阻塞
            return Account == "admin" && Password == "123456";
        }, isInputValid);

        // 高级 API 1: 执行状态监控，实时更新给 UI 比如“大马猴加载圈”！
        LoginCmd.IsExecuting.Subscribe(isRunning => 
        {
            Console.WriteLine(isRunning ? "网络请求中，按钮已自动禁用..." : "请求结束！");
        });

        // 高级 API 2: 接管错误流（防止 Task 崩溃炸掉整个应用）
        LoginCmd.ThrownExceptions.Subscribe(ex => 
        {
            Console.WriteLine($"糟糕，崩溃了被我拦截了: {ex.Message}");
        });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class ProfileViewModel : ReactiveObject
{
    [Reactive] public string FirstName { get; set; }
    [Reactive] public string LastName { get; set; }

    // OAPH 专门用来包装只读依赖属性
    private readonly ObservableAsPropertyHelper<string> _fullNameOaph;
    public string FullName => _fullNameOaph.Value;

    public ProfileViewModel()
    {
        // 将两者的流合并后，直接转为依赖属性挂载到 FullName 上
        // 只要源头属性发生任何变故，这个流会自动往下奔涌刷新！
        _fullNameOaph = this.WhenAnyValue(
                x => x.FirstName, 
                x => x.LastName, 
                (first, last) => $"{first} {last}")
            .ToProperty(this, x => x.FullName);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public SearchViewModel()
{
    this.WhenAnyValue(x => x.SearchKeyword)
        // 1. 数据清洗：如果输入是 null 或纯空格，直接剪断这条水流，不往下走了
        .Where(keyword => !string.IsNullOrWhiteSpace(keyword)) 
        
        // 2. 高频防抖：当用户正在疯狂按键盘键盘时暂停，等停止键入半秒(500ms)后才释放水流
        .Throttle(TimeSpan.FromMilliseconds(500)) 
        
        // 3. 值去重：如果拦截后的词，跟上一次查的词完全一样（可能是复制粘贴或撤销），滤除不搜！
        .DistinctUntilChanged() 
        
        // 4. 调用 API 并转化为结果流。使用 SelectMany 把异步任务展平压入主线！
        .SelectMany(async term => await ApiService.SearchAsync(term))
        
        // 5. 跨线程转接：极其重要！！上面的网络请求处于后台线程，直接赋值前端必崩。
        // 用 ObserveOn 把后续的流处理强行拉回到 Avalonia 的 UI 主线程。
        .ObserveOn(RxApp.MainThreadScheduler) 
        
        // 6. 水流终点端：执行最终动作或者赋值
        .Subscribe(searchResults => 
        {
            this.ResultList = searchResults;
        });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
using DynamicData;
using DynamicData.Binding; // 包含 Bind() 

public class DataViewModel : ReactiveObject
{
    // 系统内部的线程安全底层库
    private readonly SourceList<UserEntity> _usersSource = new SourceList<UserEntity>();

    // 给 Avalonia 绑定的 UI 展示列表！完全只读。
    private readonly ReadOnlyObservableCollection<UserEntity> _usersView;
    public ReadOnlyObservableCollection<UserEntity> UsersView => _usersView;

    public DataViewModel()
    {
        // 将底层核心连接成管道流，处理后抛给 UI
        var subscription = _usersSource.Connect()
            // 在这层管道做条件筛选
            .Filter(user => user.Age >= 18)
            // 在管道里按 Name 进行排序
            .Sort(SortExpressionComparer<UserEntity>.Ascending(u => u.Name))
            // 确保同步给前端这一刻必须回到 UI 线程！
            .ObserveOn(RxApp.MainThreadScheduler)
            // 将过滤后的只读镜像绑定给界面变量！
            .Bind(out _usersView)
            .Subscribe(); 
        
        // 数据添加：
        // 执行 AddRange，界面不会像源生 OC 那样刷新 100 遍界面，而是内部打平高效刷新 1 次！
        _usersSource.AddRange(new [] { new UserEntity{Name="A", Age=20}, new UserEntity{Name="B"} });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public partial class App : PrismApplication
{
    // 必须要被调用，以初始化 Avalonia 原生系统底座
    public override void Initialize()
    {
        AvaloniaXamlLoader.Load(this);
        base.Initialize(); // 由 Prism 包接管启动构建
    }

    // Prism 的启动核心：定义应用的 Shell(最外的大壳子主窗体)
    protected override AvaloniaObject CreateShell()
    {
        // 必须使用 IoC 容器产生主窗口。这让该窗口依赖注入进来的 VM 或服务全自动解析出来。
        return Container.Resolve<MainWindow>();
    }

    // Prism 的重头戏：所有的依赖解耦在此集中配置
    protected override void RegisterTypes(IContainerRegistry containerRegistry)
    {
        // 核心API：RegisterSingleton (一直存活单例对象)
        containerRegistry.RegisterSingleton<IGlobalSettings, GlobalSettings>();
        
        // 核心API：Register (瞬态对象，每次要的时候都 New 一个全新的)
        containerRegistry.Register<IHeavyCalculator, HeavyCalculator>();

        // 核心API：RegisterForNavigation 注册可以在大纲窗体中来回推入替换的可跳转“视图页面”。
        // 当你不传第二个参数时，默认叫页面本来的名字(如 "UserListView")作为跳转秘钥。
        containerRegistry.RegisterForNavigation<UserListView, UserListViewModel>("UsersPage");
    }
}

1
2
3
4
5
6
7
8
public class MainWindowViewModel : ReactiveObject
{
    public MainWindowViewModel(IRegionManager regionManager)
    {
        // API1: 直接粗暴在坑位里挂载一次这个对象，通常于启动时挂载左侧菜单面板。不维护历史。
        regionManager.RegisterViewWithRegion("MenuRegion", typeof(LeftMenuView));
    }
}

1
2
3
4
5
6
7
8
9
// 在侧边栏导航控件的 VM 中我们拿到参数：
var parameters = new NavigationParameters
{
    { "DepartmentId", 1024 },
    { "RoleInfo", new RoleSession{ Name="Admin" } } // 支持传递复杂实体对象类型！
};

// 指定大主干网 "MainRegion"，向内部推送名叫 "UsersPage" 的用户列表，同时抛掷出降落伞参数包！
_regionManager.RequestNavigate("MainRegion", "UsersPage", parameters);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class UserListViewModel : ReactiveObject, INavigationAware
{
    // API 1: 新页面被推挤落地后执行！处理上个跳转地发来的包袱。
    public void OnNavigatedTo(NavigationContext navigationContext)
    {
        // 从上下文中检索获取强类型参数
        if (navigationContext.Parameters.TryGetValue<int>("DepartmentId", out var depId))
        {
           LoadDataReactiveMethod(depId);
        }
    }

    // API 2: 设置是否复用本页生命周期
    // 如果返回 True：以后只要跳进你的页面，不需要走容器重新 new 构造函数，继续用这旧壳子；这就做了大页面的缓存效果。
    // 如果返回 False：每次按导航栏，只要路由进来就生成一个新的类对象替换。
    public bool IsNavigationTarget(NavigationContext navigationContext) => true;

    // API 3: 从当前页面要离开，前往别的地方的时候触发调用，可写暂存等逻辑。
    public void OnNavigatedFrom(NavigationContext navigationContext) { }
}

1
2
3
4
5
6
7
8
9
10
11
public class FormViewModel : ReactiveObject, IConfirmNavigationRequest
{
    // 相较于上面的Aware，额外增加一个必须实现的打断方法：
    public void ConfirmNavigationRequest(NavigationContext context, Action<bool> callback)
    {
        bool allowed = ShowUnsavedChangesDialogAndCheck();
        
        // 这决定了你的路由！回调 false，这辈子也别想切走；回调 true 立即允许放行！
        callback(allowed);
    }
}

1
2
3
4
5
6
7
8
9
10
11
public void OnNavigatedTo(NavigationContext context)
{
    // 把日记本拿到，赋值给你的私有变量或者绑给按钮
    var journal = context.NavigationService.Journal;
    
    // API 大全：
    bool test1 = journal.CanGoBack; // 当前上方有没有回退页？
    bool test2 = journal.CanGoForward; // 能不能前进栈堆？
    journal.GoBack(); // 执行后退！回退上个组件！
    journal.Clear(); // 核心：用户一旦登入成功进系统，把外面的所有登录页等历史一巴掌全部清除不留痕。
}

1
containerRegistry.RegisterDialog<WarnAlertView, WarnAlertViewModel>("WarnAlert");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class WarnAlertViewModel : ReactiveObject, IDialogAware
{
    public string Title => "危险弹层";

    // 这个动作事件是由 Prism 派发的关闭触发钩子，当你要关掉自己时必须 Invoke 告诉它结果。
    public event Action<IDialogResult> RequestClose;

    // 接参数弹开窗：
    public void OnDialogOpened(IDialogParameters parameters) { }
    
    public bool CanCloseDialog() => true;
    public void OnDialogClosed() { }

    // 你可以用 ReactiveCommand 调用它来手动提交结束整个弹窗的归宿
    public void HandleCloseMeLogic()
    {
        // 送出返回包裹对象：ButtonResult(OK/Cancel...) 以及 DialogParameters 回传结果给召唤你的底层系统。
        var res = new DialogResult(ButtonResult.OK);
        RequestClose?.Invoke(res);
    }
}

1
2
3
4
5
6
7
// _dialog 注入拿来的 IDialogService
_dialog.ShowDialog("WarnAlert", new DialogParameters{ {"msg","断网拉！"} }, result => 
{
    if(result.Result == ButtonResult.OK) { 
        // 别人按了关闭弹窗并且确认了！
    }
});

1
public class SongChangedEvent : PubSubEvent<SongModel> { }

1
2
// _eventAggr 注入的 IEventAggregator
_eventAggr.GetEvent<SongChangedEvent>().Publish(new SongModel(id:112));

1
2
3
4
5
6
7
8
9
10
11
12
_eventAggr.GetEvent<SongChangedEvent>().Subscribe(
    payload => { /* 开始改变前台歌词状态更新 ViewModel... */ },
    
    // 高级 API 选项1：由于可能发起线程是在后端查询库里，通知你直接切换在 Avalonia 界面层执行处理：
    ThreadOption.UIThread,
    
    // 高级 API 选项2：是否保留对订阅者的强引用？一般选 false 做弱引用，不怕页面死循环销毁不了。
    false,
    
    // 高级 API 选项3：只有发生什么样的特指内容你才关心并继续拦截动作？过滤管道！
    song => song.Duration > 60 // 过滤掉小于 60 秒的数据
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
using Prism.Ioc;
using Prism.Modularity;
using Prism.Regions;

public class FinanceModule : IModule
{
    // A. 第一个生命周期触发：该 DLL 的地皮在此向主系统统揽地登记自己的子服务和内部单独导航的窗口！
    public void RegisterTypes(IContainerRegistry containerRegistry)
    {
        containerRegistry.RegisterForNavigation<InvoiceView>("InvoiceBoard");
        containerRegistry.RegisterSingleton<ITaxApiService, TaxApiService>();
    }

    // B. 第二个初始化生命周期触发：已经准备就绪时；用于干啥？
    // 用于拿总装的 RegionManager 神不知鬼不觉把 DLL 内专属私有按钮页面塞进全局菜单的坑！！
    public void OnInitialized(IContainerProvider containerProvider)
    {
        var regions = containerProvider.Resolve<IRegionManager>();
        
        // 全世界的挂载主程序甚至不用这个界面长啥样，模块自动去主界面侧边栏里安插了自己的财务专用图标与列表！
        regions.RegisterViewWithRegion("GlobalSidebarRegion", typeof(FinanceIconBtnView));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
    // 方式1：强引用（主项目在代码里直接 Add Reference 依赖了这个分库）
    moduleCatalog.AddModule<FinanceModule>();
}

// 方式2的黑科技API：基于动态抛目录无引用的极致加载！！！
// 主程序不写死引用代码！所有的团队自己编译了自己的 .dll 后直接甩到一个 "Plugins" 物理文件夹就能直接接管激活功能！！
protected override IModuleCatalog CreateModuleCatalog()
{
    // 此目录扫描将在启动期载入插件加载入一切路由及模块类库中提供的资源分配！
    return new DirectoryModuleCatalog() { ModulePath = @".\Plugins" };
}