Avalonia 深度架构全景指南：现代 MVVM 核心原理、ReactiveUI 响应式精讲与 Prism 企业级微核扩展#

1
最高优先级  [1] 活跃动画 (Active Animations)
2
    ↑      [2] 本地显式赋值 (Local Values, 如 XAML 中直接写 Background="Red")
3
    │      [3] 样式触发器 (Style Triggers / Selectors)
4
    │      [4] 控件模板 (Control Template Values)
5
    │      [5] 视觉树层叠继承 (Inherited, 如 TextElement.FontSize 从上层父容器向下遗传)
6
最低优先级  [6] 属性默认值 (Default Value Metadata)

1
public class CustomMetricControl : Control
2
{
3
    // 1. 定义真实的 C# 私有字段
4
    private double _currentValue;
5

6
    // 2. 注册为 DirectProperty：将 Getter 与 Setter 的委托直接指向该字段
7
    public static readonly DirectProperty<CustomMetricControl, double> CurrentValueProperty =
8
        AvaloniaProperty.RegisterDirect<CustomMetricControl, double>(
9
            nameof(CurrentValue),
10
            o => o.CurrentValue,
11
            (o, v) => o.CurrentValue = v);
12

13
    // 3. 对外暴露标准 CLR 属性包装
14
    public double CurrentValue
15
    {
16
        get => _currentValue;
17
        set => SetAndRaise(CurrentValueProperty, ref _currentValue, value);
18
    }
19
}

1
┌─────────────────────────┐          数据绑定 (DataBinding)         ┌─────────────────────────┐
2
│       View (XAML)       │ <====================================> │     ViewModel (C#)      │
3
│                         │                                        │                         │
4
│ • Controls (Button, ...)│  属性变动通知 (INPC)                   │ • Observable Properties │
5
│ • Layouts (Grid, Stack) │  <-----------------------------------  │ • Commands (ICommand)   │
6
│ • Animations / Styles   │  用户交互指令触发 (Command Execution)  │ • UI Logic Orchestration│
7
│                         │  ----------------------------------->  │                         │
8
└─────────────────────────┘                                        └────────────┬────────────┘
9
                                                                                │ 业务调用 / 领域事件
10
                                                                                ▼
11
                                                                   ┌─────────────────────────┐
12
                                                                   │       Model Layer       │
13
                                                                   │                         │
14
                                                                   │ • Database / Entity     │
15
                                                                   │ • Web API Client        │
16
                                                                   │ • Hardware / Motion SDK │
17
                                                                   └─────────────────────────┘

1
<!-- WPF 传统运行时绑定 -->
2
<TextBlock Text="{Binding UserName}" />

1
<UserControl xmlns="https://github.com/avaloniaui"
2
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
3
             xmlns:vm="using:MyApplication.ViewModels"
4
             x:Class="MyApplication.Views.UserProfileView"
5
             x:DataType="vm:UserProfileViewModel"
6
             x:CompileBindings="True">
7

8
    <!-- 编译期绑定：享受编译器强类型检查与 IL 直连访问 -->
9
    <StackPanel Spacing="10">
10
        <TextBox Text="{Binding UserName, Mode=TwoWay}" />
11
        <Button Content="保存资料" Command="{Binding SaveProfileCommand}" />
12
    </StackPanel>
13
</UserControl>

1
using CommunityToolkit.Mvvm.ComponentModel;
2

3
namespace MyApplication.ViewModels;
4

5
public partial class UserProfileViewModel : ObservableObject
6
{
7
    [ObservableProperty]
8
    private string _userName = string.Empty;
9

10
    [ObservableProperty]
11
    [NotifyPropertyChangedFor(nameof(DisplayName))]
12
    private int _level;
13

14
    public string DisplayName => $"[{Level}级会员] {UserName}";
15
}

1
// <auto-generated> 编译器在后台生成的代码实录
2
namespace MyApplication.ViewModels;
3

4
partial class UserProfileViewModel
5
{
6
    public string UserName
7
    {
8
        get => _userName;
9
        set
10
        {
11
            if (!EqualityComparer<string>.Default.Equals(_userName, value))
12
            {
13
                OnUserNameChanging(value); // 变动前拦截
14
                OnPropertyChanging(nameof(UserName));
15

16
                _userName = value;
17

18
                OnUserNameChanged(value);  // 变动后回调
19
                OnPropertyChanged(nameof(UserName));
20
            }
21
        }
22
    }
23

24
    // 编译器自动生成的偏函数，供开发者随时介入业务逻辑
25
    partial void OnUserNameChanging(string value);
26
    partial void OnUserNameChanged(string value);
27

28
    public int Level
29
    {
30
        get => _level;
31
        set
32
        {
33
            if (!EqualityComparer<int>.Default.Equals(_level, value))
34
            {
35
                _level = value;
36
                OnPropertyChanged(nameof(Level));
37
                // 自动展开的级联通知属性！
38
                OnPropertyChanged(nameof(DisplayName));
39
            }
40
        }
41
    }
42
}

1
using CommunityToolkit.Mvvm.Input;
2

3
public partial class UserProfileViewModel : ObservableObject
4
{
5
    [ObservableProperty]
6
    [NotifyCanExecuteChangedFor(nameof(SubmitOrderCommand))]
7
    private string _orderNumber = string.Empty;
8

9
    private bool CanSubmitOrder => !string.IsNullOrWhiteSpace(OrderNumber);
10

11
    // 1. 自动生成 IAsyncRelayCommand 异步强类型命令
12
    // 2. 通过 CanExecute 挂接可用性检查规则
13
    [RelayCommand(CanExecute = nameof(CanSubmitOrder))]
14
    private async Task SubmitOrderAsync(CancellationToken cancellationToken)
15
    {
16
        try
17
        {
18
            // 模拟远程 API 调用
19
            await Task.Delay(2000, cancellationToken);
20
            // 业务保存逻辑...
21
        }
22
        catch (OperationCanceledException)
23
        {
24
            // 优雅处理用户取消
25
        }
26
    }
27
}

1
using ReactiveUI;
2

3
public class SensorMonitorViewModel : ReactiveObject
4
{
5
    private double _temperature;
6
    public double Temperature
7
    {
8
        get => _temperature;
9
        // API: bool RaiseAndSetIfChanged<TObj, TRet>(ref TRet backingField, TRet newValue)
10
        set => this.RaiseAndSetIfChanged(ref _temperature, value);
11
    }
12
}

1
1. 校验 EqualityComparer<T>.Default.Equals(backingField, newValue)
2
   └─ 若相等：立即 return false（阻断后续一切操作，节省 CPU）
3
2. 触发 Changing 事件流（向所有订阅者广播：该属性马上要变了）
4
3. 执行 backingField = newValue（安全内存写入）
5
4. 触发 Changed 事件流（向所有订阅者广播：属性已经变成新值）
6
5. 触发标准 INotifyPropertyChanged.PropertyChanged（通知 Avalonia 界面重绘）
7
6. return true

1
public class SensorMonitorViewModel : ReactiveObject
2
{
3
    // Fody 会在编译后自动生成完整的 RaiseAndSetIfChanged 代码逻辑
4
    [Reactive] public double Temperature { get; set; }
5
    [Reactive] public double Pressure { get; set; }
6
    [Reactive] public bool IsAlarmTriggered { get; set; }
7
}

1
public class SearchViewModel : ReactiveObject
2
{
3
    [Reactive] public string SearchQuery { get; set; } = string.Empty;
4
    [Reactive] public ObservableCollection<SearchResultItem> SearchResults { get; set; } = new();
5
    [Reactive] public bool IsSearching { get; set; }
6

7
    public SearchViewModel(ISearchApiService apiService)
8
    {
9
        // 核心编排管道
10
        this.WhenAnyValue(x => x.SearchQuery)
11
            // 1. 数据清洗：滤除空白字符
12
            .Select(query => query?.Trim() ?? string.Empty)
13

14
            // 2. 高频防抖：当用户快速打字时阻断水流，直到用户停顿达到 400ms 后才放行
15
            .Throttle(TimeSpan.FromMilliseconds(400))
16

17
            // 3. 值去重：若用户连续输入又按退格变回原词，不触发重复检索
18
            .DistinctUntilChanged()
19

20
            // 4. 线程调度：将耗时网络请求转到后台线程池，并开启搜索状态
21
            .Do(_ => IsSearching = true)
22
            .ObserveOn(RxApp.TaskpoolScheduler)
23

24
            // 5. 关键操作符 Switch：展平异步请求！
25
            // 如果上一次查询还在网络传输中，而用户又打出了新词，
26
            // Switch 会自动丢弃并取消前一个过期的 HTTP 请求，只保留最新一次的查询结果！
27
            .Select(query => Observable.FromAsync(ct => apiService.QueryAsync(query, ct)))
28
            .Switch()
29

30
            // 6. 线程调度：极其关键！！更新 UI 必须拉回到 Avalonia 的 UI 主线程
31
            .ObserveOn(RxApp.MainThreadScheduler)
32

33
            // 7. 终点消费
34
            .Subscribe(results =>
35
            {
36
                IsSearching = false;
37
                SearchResults.Clear();
38
                foreach (var item in results)
39
                {
40
                    SearchResults.Add(item);
41
                }
42
            }, ex =>
43
            {
44
                IsSearching = false;
45
                // 全局错误兜底，水流不中断
46
                Console.WriteLine($"搜索异常被安全捕获: {ex.Message}");
47
            });
48
    }
49
}

1
// 监听三个字段，动态生成一条是否允许注册的布尔流
2
IObservable<bool> canRegisterStream = this.WhenAnyValue(
3
    x => x.Username,
4
    x => x.Password,
5
    x => x.ConfirmPassword,
6
    (user, pwd, confirm) =>
7
        !string.IsNullOrWhiteSpace(user) &&
8
        user.Length >= 4 &&
9
        !string.IsNullOrEmpty(pwd) &&
10
        pwd.Length >= 6 &&
11
        pwd == confirm
12
);

1
public class LoginViewModel : ReactiveObject
2
{
3
    [Reactive] public string Account { get; set; } = string.Empty;
4
    [Reactive] public string Password { get; set; } = string.Empty;
5

6
    // 命令的输入参数为 Unit（代表无参数），执行结果返回 LoginResultModel
7
    public ReactiveCommand<Unit, LoginResultModel> ExecuteLoginCommand { get; }
8

9
    public LoginViewModel(IAuthenticationService authService)
10
    {
11
        // 1. 构建可用性响应流
12
        IObservable<bool> canLogin = this.WhenAnyValue(
13
            x => x.Account,
14
            x => x.Password,
15
            (acc, pwd) => !string.IsNullOrWhiteSpace(acc) && pwd?.Length >= 6
16
        );
17

18
        // 2. 创建异步命令：把执行逻辑与可用性流深度绑定
19
        ExecuteLoginCommand = ReactiveCommand.CreateFromTask(async () =>
20
        {
21
            // 在此期间，ExecuteLoginCommand.IsExecuting 自动变成 true！
22
            // 绑定的前台 Button 自动置灰，绝无重复点击风险！
23
            return await authService.LoginAsync(Account, Password);
24
        }, canLogin);
25

26
        // 3. 监听执行结果流：任务一旦成功完成，立即在此处理业务路由
27
        ExecuteLoginCommand.Subscribe(result =>
28
        {
29
            if (result.Success)
30
            {
31
                NavigateToDashboard(result.Token);
32
            }
33
        });
34

35
        // 4. 接管专属异常流：极其重要！
36
        // 如果网络断开抛出 HttpRequestException，任务不会导致整个 App 崩溃闪退，
37
        // 而是被隔离并自动抛入 ThrownExceptions 流中！
38
        ExecuteLoginCommand.ThrownExceptions
39
            .ObserveOn(RxApp.MainThreadScheduler)
40
            .Subscribe(ex =>
41
            {
42
                ShowErrorMessageBox($"登录失败，网络异常: {ex.Message}");
43
            });
44
    }
45
}

1
<!-- 当登录任务正在后台跑时，ProgressBar 自动显示并开启旋转 -->
2
<ProgressBar IsIndeterminate="True"
3
             IsVisible="{Binding ExecuteLoginCommand.IsExecuting^}" />

1
┌───────────────────────┐
2
│  底层线程安全数据源   │
3
│  SourceCache<T, TKey> │  (在后台工作线程中极速进行 AddOrUpdate / Remove)
4
└───────────┬───────────┘
5
            │
6
            ▼ Connect() 产生变换管道流
7
┌────────────────────────────────────────────────────────┐
8
│  .Filter(item => item.IsOnline)        // 动态过滤     │
9
│  .Sort(SortExpressionComparer.Asc)     // 规则排序     │
10
│  .ObserveOn(RxApp.MainThreadScheduler) // 线程调度切回 │
11
└───────────┬────────────────────────────────────────────┘
12
            │
13
            ▼ .Bind(out _displayList)
14
┌────────────────────────────────────────────────────────┐
15
│  前台只读展示镜像列表 (ReadOnlyObservableCollection)   │  (单次批量合并刷新界面)
16
└────────────────────────────────────────────────────────┘

1
using DynamicData;
2
using DynamicData.Binding;
3

4
public record TelemetryPoint(int SensorId, string SensorName, double Value, DateTime Timestamp);
5

6
public class TelemetryStreamViewModel : ReactiveObject
7
{
8
    // 1. 底层存储库：按 SensorId 为唯一主键建立高速缓存（线程安全）
9
    private readonly SourceCache<TelemetryPoint, int> _telemetryCache = new(x => x.SensorId);
10

11
    // 2. 暴露给 Avalonia XAML 绑定的只读集合
12
    private readonly ReadOnlyObservableCollection<TelemetryPoint> _telemetryView;
13
    public ReadOnlyObservableCollection<TelemetryPoint> TelemetryView => _telemetryView;
14

15
    [Reactive] public double WarningThreshold { get; set; } = 80.0;
16

17
    public TelemetryStreamViewModel()
18
    {
19
        // 3. 构建动态响应式数据流水线
20
        // 当 WarningThreshold 改变时，动态刷新 Filter 规则！
21
        var dynamicFilter = this.WhenAnyValue(x => x.WarningThreshold)
22
            .Select(threshold => new Func<TelemetryPoint, bool>(point => point.Value >= threshold));
23

24
        _telemetryCache.Connect()
25
            // 接入动态过滤器
26
            .Filter(dynamicFilter)
27
            // 按照数值从大到小排序
28
            .Sort(SortExpressionComparer<TelemetryPoint>.Descending(x => x.Value))
29
            // 节流控制：高频数据涌入时，最多每 100ms 向 UI 刷新一次批次结果，避免界面撕裂
30
            .Throttle(TimeSpan.FromMilliseconds(100))
31
            // 安全切回 Avalonia UI 线程
32
            .ObserveOn(RxApp.MainThreadScheduler)
33
            // 绑定到展示集合中
34
            .Bind(out _telemetryView)
35
            .Subscribe();
36
    }
37

38
    // 后台网络线程（如 MQTT / WebSocket）以 1000Hz 狂飙调用该方法
39
    public void OnTelemetryPacketReceived(IList<TelemetryPoint> batchPackets)
40
    {
41
        // 无论并发多高，直接批量写入缓存，绝不报跨线程异常，更不会卡死 UI 渲染！
42
        _telemetryCache.AddOrUpdate(batchPackets);
43
    }
44
}

1
<prism:PrismApplication xmlns="https://github.com/avaloniaui"
2
                        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
3
                        xmlns:prism="http://prismlibrary.com/"
4
                        x:Class="MyEnterpriseApp.App">
5
    <prism:PrismApplication.Styles>
6
        <FluentTheme />
7
    </prism:PrismApplication.Styles>
8
</prism:PrismApplication>

1
using Avalonia;
2
using Avalonia.Markup.Xaml;
3
using Prism.DryIoc;
4
using Prism.Ioc;
5
using Prism.Modularity;
6
using Prism.Regions;
7

8
namespace MyEnterpriseApp;
9

10
public partial class App : PrismApplication
11
{
12
    // 1. 初始化 XAML 资源与 Prism 运行环境
13
    public override void Initialize()
14
    {
15
        AvaloniaXamlLoader.Load(this);
16
        base.Initialize(); // 触发 Prism 底层管道构建
17
    }
18

19
    // 2. 引导应用外壳（Shell）：从 IoC 容器中解析出顶层宿主主窗体
20
    protected override AvaloniaObject CreateShell()
21
    {
22
        return Container.Resolve<Views.MainWindow>();
23
    }
24

25
    // 3. 依赖注入类型集中注册
26
    protected override void RegisterTypes(IContainerRegistry containerRegistry)
27
    {
28
        // A. 注册长生命周期单例服务
29
        containerRegistry.RegisterSingleton<ISettingsService, SettingsService>();
30
        containerRegistry.RegisterSingleton<IHardwareController, HardwareController>();
31

32
        // B. 注册瞬态业务逻辑计算器（每次请求返回新实例）
33
        containerRegistry.Register<IAlgorithmEngine, FastAlgorithmEngine>();
34

35
        // C. 核心：将页面注册到路由系统，并绑定视图与视图模型！
36
        // 第二个字符串参数为在导航中定位该页面的“统一路由别名”
37
        containerRegistry.RegisterForNavigation<Views.DashboardView, ViewModels.DashboardViewModel>("DashboardPage");
38
        containerRegistry.RegisterForNavigation<Views.UserListView, ViewModels.UserListViewModel>("UsersPage");
39
    }
40
}

1
<Window xmlns="https://github.com/avaloniaui"
2
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
3
        xmlns:prism="http://prismlibrary.com/"
4
        x:Class="MyEnterpriseApp.Views.MainWindow"
5
        Title="企业级微核管理控制台" Width="1200" Height="800">
6

7
    <Grid ColumnDefinitions="260, *">
8
        <!-- 左侧菜单栏区域：挖一个名为 MenuRegion 的坑 -->
9
        <ContentControl Grid.Column="0"
10
                        prism:RegionManager.RegionName="MenuRegion" />
11

12
        <!-- 右侧主展示工作区：挖一个名为 MainWorkRegion 的坑 -->
13
        <!-- 使用带动画过渡的容器呈现更佳视觉效果 -->
14
        <TransitioningContentControl Grid.Column="1"
15
                                    prism:RegionManager.RegionName="MainWorkRegion" />
16
    </Grid>
17
</Window>

1
public class MainWindowViewModel : ReactiveObject
2
{
3
    public MainWindowViewModel(IRegionManager regionManager)
4
    {
5
        // 应用程序启动时，直接将 LeftSideMenuView 挂载进入左侧菜单区域
6
        regionManager.RegisterViewWithRegion("MenuRegion", typeof(LeftSideMenuView));
7
    }
8
}

1
public class LeftSideMenuViewModel : ReactiveObject
2
{
3
    private readonly IRegionManager _regionManager;
4

5
    public ReactiveCommand<string, Unit> NavigateCommand { get; }
6

7
    public LeftSideMenuViewModel(IRegionManager regionManager)
8
    {
9
        _regionManager = regionManager;
10

11
        NavigateCommand = ReactiveCommand.Create<string>(targetPage =>
12
        {
13
            // 打包导航参数（支持任意基本数据类型、复杂模型甚至委托闭包）
14
            var navParams = new NavigationParameters
15
            {
16
                { "BatchId", 20261031 },
17
                { "OperatorInfo", new OperatorSession(Name: "Admin", Role: "Supervisor") }
18
            };
19

20
            // 命令区域管理器：在右侧 MainWorkRegion 中，推入对应页面并空降参数包！
21
            _regionManager.RequestNavigate("MainWorkRegion", targetPage, navParams);
22
        });
23
    }
24
}

1
public class UserListViewModel : ReactiveObject, INavigationAware
2
{
3
    [Reactive] public int CurrentBatchId { get; set; }
4

5
    // 1. 当页面被推入并成功挂载到视口时触发（开箱接收上游发来的包裹）
6
    public void OnNavigatedTo(NavigationContext navigationContext)
7
    {
8
        if (navigationContext.Parameters.TryGetValue<int>("BatchId", out var batchId))
9
        {
10
            CurrentBatchId = batchId;
11
            LoadBatchDataReactive(batchId);
12
        }
13
    }
14

15
    // 2. 核心判定：是否复用当前视图实例？
16
    // 返回 True  -> 开启单例缓存模式！下次再跳转到该页面时，不再重新构造对象，保持原先的滚动条位置与输入状态！
17
    // 返回 False -> 瞬态模式！每次跳入都重新 new 一个全新的页面对象，自动丢弃旧垃圾。
18
    public bool IsNavigationTarget(NavigationContext navigationContext) => true;
19

20
    // 3. 当用户点击侧边栏准备离开本页面前触发（执行现场暂存或取消后台未完任务）
21
    public void OnNavigatedFrom(NavigationContext navigationContext)
22
    {
23
        // 可以在此中断正在跑的高频轮询
24
    }
25
}

1
public class OrderEditViewModel : ReactiveObject, IConfirmNavigationRequest
2
{
3
    [Reactive] public bool HasUnsavedChanges { get; set; }
4

5
    // 实现拦截打断方法
6
    public void ConfirmNavigationRequest(NavigationContext context, Action<bool> continuationCallback)
7
    {
8
        if (HasUnsavedChanges)
9
        {
10
            // 弹出询问对话框
11
            ShowConfirmDialog("当前工单有未保存的修改，确定要强行离开吗？", canLeave =>
12
            {
13
                // 回调传递 true 允许导航放行；传递 false 则强行掐断路由，用户留在本页面！
14
                continuationCallback(canLeave);
15
            });
16
        }
17
        else
18
        {
19
            // 无脏数据，立即放行
20
            continuationCallback(true);
21
        }
22
    }
23

24
    // 同时实现 INavigationAware 其他必要接口...
25
    public void OnNavigatedTo(NavigationContext navigationContext) { }
26
    public bool IsNavigationTarget(NavigationContext navigationContext) => false;
27
    public void OnNavigatedFrom(NavigationContext navigationContext) { }
28
}

1
public void OnNavigatedTo(NavigationContext navigationContext)
2
{
3
    // 获取当前视口的导航日志本
4
    IRegionNavigationJournal journal = navigationContext.NavigationService.Journal;
5

6
    // 常用 API 矩阵：
7
    bool canBack = journal.CanGoBack;        // 检查是否存在上一步历史
8
    bool canForward = journal.CanGoForward;  // 检查是否存在下一步历史
9

10
    // 执行回退操作：
11
    // journal.GoBack();
12

13
    // 关键生产用法：用户在登录页登录成功跳入系统主页后，一键抹平所有回退历史，防止用户按返回键重新回到登录界面！
14
    // journal.Clear();
15
}

1
containerRegistry.RegisterDialog<Views.DangerConfirmView, ViewModels.DangerConfirmViewModel>("DangerConfirmDialog");

1
public class DangerConfirmViewModel : ReactiveObject, IDialogAware
2
{
3
    public string Title => "关键操作确认";
4

5
    // 核心事件：当 ViewModel 决定关闭自己时，触发该事件通知底层容器销毁视口
6
    public event Action<IDialogResult>? RequestClose;
7

8
    public ReactiveCommand<Unit, Unit> ConfirmCommand { get; }
9
    public ReactiveCommand<Unit, Unit> CancelCommand { get; }
10

11
    public DangerConfirmViewModel()
12
    {
13
        ConfirmCommand = ReactiveCommand.Create(() =>
14
        {
15
            // 回传带参数的确认结果
16
            var result = new DialogResult(ButtonResult.OK, new DialogParameters { { "ConfirmedTime", DateTime.Now } });
17
            RequestClose?.Invoke(result);
18
        });
19

20
        CancelCommand = ReactiveCommand.Create(() =>
21
        {
22
            RequestClose?.Invoke(new DialogResult(ButtonResult.Cancel));
23
        });
24
    }
25

26
    public bool CanCloseDialog() => true;
27
    public void OnDialogClosed() { }
28
    public void OnDialogOpened(IDialogParameters parameters)
29
    {
30
        // 接收主界面传来的提示信息
31
        string message = parameters.GetValue<string>("WarningMessage");
32
    }
33
}

1
// 构造函数注入 IDialogService
2
public class DashboardViewModel : ReactiveObject
3
{
4
    private readonly IDialogService _dialogService;
5

6
    public DashboardViewModel(IDialogService dialogService)
7
    {
8
        _dialogService = dialogService;
9
    }
10

11
    public void OnDeleteSystemClicked()
12
    {
13
        var parameters = new DialogParameters { { "WarningMessage", "格式化操作将清除所有数据！" } };
14

15
        // 统一以异步回调/等待的方式唤起模态弹窗，跨平台表现 100% 统一
16
        _dialogService.ShowDialog("DangerConfirmDialog", parameters, result =>
17
        {
18
            if (result.Result == ButtonResult.OK)
19
            {
20
                ExecuteWipeData();
21
            }
22
        });
23
    }
24
}

1
using Prism.Ioc;
2
using Prism.Modularity;
3
using Prism.Regions;
4

5
namespace MyCompany.VisionModule;
6

7
public class VisionModule : IModule
8
{
9
    // 生命周期阶段 1：模块向主系统的 IoC 容器注册自身私有的服务与视图路由
10
    public void RegisterTypes(IContainerRegistry containerRegistry)
11
    {
12
        containerRegistry.RegisterSingleton<IVisionAlgorithm, HalconVisionAlgorithm>();
13
        containerRegistry.RegisterForNavigation<Views.CameraCalibrationView>("CameraCalibrationPage");
14
    }
15

16
    // 生命周期阶段 2：应用准备就绪后触发
17
    // 模块神不知鬼不觉地拿到宿主的 RegionManager，将自己的入口按钮塞进全局侧边栏！
18
    public void OnInitialized(IContainerProvider containerProvider)
19
    {
20
        var regionManager = containerProvider.Resolve<IRegionManager>();
21

22
        // 宿主主界面完全不知道视觉模块的具体实现，视觉模块自动在 GlobalSidebarRegion 挖好的槽位中挂上了自己的图标！
23
        regionManager.RegisterViewWithRegion("GlobalSidebarRegion", typeof(Views.VisionSidebarIconView));
24
    }
25
}

1
protected override IModuleCatalog CreateModuleCatalog()
2
{
3
    // 指定插件存放的物理相对目录
4
    // 各业务子团队只需编译出各自的 DLL 丢进该文件夹，主程序启动即可自动识别并激活全部功能！
5
    return new DirectoryModuleCatalog { ModulePath = @".\Plugins" };
6
}