//拿到当前主程序
var main = Application.Current.MainWindow;
var window=Container.Resolve<MainWindow>();
//这行代码的作用是确保新创建的MainWindow实例成为当前应用程序的主窗口，以便用户可以看到并与其交互
//不明具体原因,但还是加上好
Application.Current.MainWindow = window;
window.Show();
main.Close();

var mainWindow = new MainWindow();
// 注册视图模型
containerRegistry.Register<ViewModels.MainWindowViewModel>();

var mainWindow = new MainWindow();
mainWindow.Show();
//这种方式不是prism支持的通过依赖注入来创建窗口的方式,视图模型的构造函数,prism的导航功能都可能无法正常工作

RegionManager.SetRegionName(指定ContentControl的name,自定义区域名);

 public MainWindowViewModel(IRegionManager regionManager)
 {
     //在ContentRegion区域中显示Views目录下的ContentView内容
     regionManager.RegisterViewWithRegion("ContentRegion", typeof(Views.view1));
 }
//注意Views目录下的view1不能是页面或窗口,只能是用户控件,不然报错

private void SetRegion(ContentControl contentControl)
{
    if (contentControl != null)
    {
        RegionManager.SetRegionName(contentControl, RegionName);
        RegionManager.SetRegionManager(contentControl, _regionManager);
    }
}

//通过下面代码来切换RegionName对应的视图容器中的内容:navigatePath
_regionManager.RequestNavigate(RegionName, navigatePath, NavigationCallback);

private void NavigationCallback(NavigationResult result)
{
    if (result.Result == true)
    {
        Log.Debug($"导航成功: {result.Context.Uri}");
    }
    else
    {
        Log.Error($"导航失败: {result.Error?.Message}");
    }
}

class TabControlAdapter : RegionAdapterBase<TabControl>
    {
        public TabControlAdapter(IRegionBehaviorFactory regionBehaviorFactory) : base(regionBehaviorFactory)
        {
        }

        protected override void Adapt(IRegion region, TabControl regionTarget)
        {
            region.Views.CollectionChanged += (s, e) =>
            {
                if (e.Action == NotifyCollectionChangedAction.Add)
                    foreach (UserControl item in e.NewItems)
                    {
                        regionTarget.Items.Add(new TabItem { Header = item.Name, Content = item });
                    }
                else if (e.Action == NotifyCollectionChangedAction.Remove)
                    foreach (UserControl item in e.OldItems)
                    {
                        var tabTodelete = regionTarget.Items.OfType<TabItem>().FirstOrDefault(n => n.Content == item);
                        regionTarget.Items.Remove(tabTodelete);
                    }

            };
        }


        protected override IRegion CreateRegion()
        {
            return new SingleActiveRegion();
        }
    }

var tabRegion = _regionManager.Regions[RegionNames.AnalysisTabRegion];

if (tabRegion.Views.Any())
    return;

var historyJournalView = _containerProvider.Resolve<HistoryJournalView>();
var historyDataView = _containerProvider.Resolve<HistoryDataView>();
var jobJournalView = _containerProvider.Resolve<JobJournalView>();

tabRegion.Add(historyJournalView);
tabRegion.Add(historyDataView);
tabRegion.Add(jobJournalView);

tabRegion.Activate(historyJournalView);

public class ModuleAModule : IModule
    {
        /// <summary>
        /// 通知模块已被初始化。
  			///	执行诸如视图注册或任何其他模块初始化代码之类的操作
        /// </summary>
        /// <param name="containerProvider"></param>
        public void OnInitialized(IContainerProvider containerProvider)
        {
          //在这里可以进行区域和模块的连接(若有需要的话)
        }

        /// <summary>
  			/// 当一个模块被加载到应用程序中时，首先调用RegisterTypes
        /// 应用于注册模块实现的任何服务或功能
        /// </summary>
        /// <param name="containerRegistry"></param>
        public void RegisterTypes(IContainerRegistry containerRegistry)
        {
          //注册视图通过如下方式:
          //使用containerProvider找回Prism RegionManage的实例
          var regionManager = containerProvider.Resolve<IRegionManager>();
          //通过RegionManage注册视图
        	regionManager.RegisterViewWithRegion("MyModuleView", typeof(Views.ThisModuleView));
        }
    }

public partial class App
{
  protected override Window CreateShell()
  {
    return Container.Resolve<MainWindow>();
  }

  protected override void RegisterTypes(IContainerRegistry containerRegistry)
  {

  }
  //手动代码导入模块需要重写的方法
  protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
  {
    //添加模块A
    moduleCatalog.AddModule<ModuleAModule>();
  }
}

public partial class App
   {
			//目录扫描的方式导入模块需要重写该方法   
       protected override IModuleCatalog CreateModuleCatalog()
       {
           return new DirectoryModuleCatalog() { ModulePath=@".\Modules" };//表示当前目录下的Modules文件夹下,当前目录是可执行文件的位置
       }
   }

public partial class App
   {
       protected override IModuleCatalog CreateModuleCatalog()
       {
           return new ConfigurationModuleCatalog();
       }
   }

public partial class App
{
    protected override IModuleCatalog CreateModuleCatalog()
    {
        return new XamlModuleCatalog(new Uri("/Modules;component/ModuleCatalog.xaml", UriKind.Relative));
    }
}

public class ModuleAModule : IModule
{
    private readonly IRegionManager _regionManager;

    public ModuleAModule(IRegionManager regionManager)
    {
        _regionManager = regionManager;
    }

    public void OnInitialized(IContainerProvider containerProvider)
    {
        _regionManager.RegisterViewWithRegion("ContentRegion", typeof(ViewA));
    }

    public void RegisterTypes(IContainerRegistry containerRegistry)
    {
            
    }
}

// 通用注册
containerRegistry.Register<IService, MyServiceImpl>(); 
// 单例注册
containerRegistry.RegisterSingleton<IService, MyServiceImpl>(); 
// 实例注册
var instance = new MyServiceImpl();
containerRegistry.RegisterInstance<IService>(instance); 
// 作用域注册
containerRegistry.RegisterScoped<IService, MyServiceImpl>(); 

containerRegistry.RegisterSingleton<IService, MyServiceImpl>();
//这个示例中，通过 containerRegistry 注册了单例实例。其他代码可以通过 IService 接口来使用该单例服务

public class MyViewModel : BindableBase
{
    private readonly IContainerProvider _containerProvider;

    public MyViewModel(IContainerProvider containerProvider)
    {
        _containerProvider = containerProvider;
    }

    public void SomeMethod()
    {
        var myService = _containerProvider.Resolve<IMyService>();
        myService.DoSomething();
    }
}

public class MyViewModel : BindableBase
{
    private readonly IMyService _myService;

    public MyViewModel(IMyService myService)
    {
        _myService = myService;
    }
}

public class TestViewModel : BindableBase
{
  public TestViewModel()
  {
    //赋值
    Message = "hello";
    //DelegateCommand如果有第二个参数,可以传入一个方法,通过返回true/false来控制命令是否可执行
    SendCommand = new DelegateCommand(() =>
    {
      Message = "hello world!";
    });
  }
  private string _message;

  public string Message
  {
    get { return _message; }
    set { _message = value; RaisePropertyChanged(); }
  }
  
  //在Prism当中, 你可以使用DelegateCommand及带参数的Command
   public DelegateCommand SendCommand { get; private set; }
   //public DelegateCommand<string> SendMessageCommand { get;private set; }
}

public CompositeCommand 复合命令名 {  get; private set; }
//初始化复合命令,并给复合命令注册普通命令
复合命令名 = new CompositeCommand();
复合命令名.RegisterCommand(命令名);
复合命令名.RegisterCommand(命令名2);

 public class ViewAViewModel: BindableBase
 {
		private string message;

     public ViewAViewModel()
     {
Message = "hello";
         SendCommand = new DelegateCommand(() =>
{
	Message = "hello world!";
});
         SendCommand2=new DelegateCommand(() => {
             Message += "zeroko14";
         });
         //初始化复合命令
         SendAll = new CompositeCommand();
//设置复合命令注册命令,可以注册多个命令
SendAll.RegisterCommand(SendCommand);
SendAll.RegisterCommand(SendCommand2);
     }

     public string Message
		{
get { return message; }
set { message = value; RaisePropertyChanged(); }
		}

		public DelegateCommand SendCommand { get; private set; }
 
     public DelegateCommand SendCommand2 { get; private set; }

     //复合命令
     public CompositeCommand SendAll {  get; private set; }

	}

//创建事件
public class SavedEvent : PubSubEvent<string> { }

//发布
IEventAggregator.GetEvent<SavedEvent>().Publish("some value");

//订阅
IEventAggregator.GetEvent<SavedEvent>().Subscribe(message=>
{
    //do something
});

eventAggregator.GetEvent<MessageSentEvent>().Subscribe(
  						 arg =>{
                   //do something
               },
               ThreadOption.PublisherThread,
               false,
               //设置条件为token等于“MessageListViewModel” 则接收消息
               message => message.token.Equals(nameof(MessageListViewModel)));

namespace prismTestNew.ViewModels
{
    public class ViewAViewModel: BindableBase
    {
        private readonly IEventAggregator eventAggregator;
        private string message;

        public ViewAViewModel(IEventAggregator eventAggregator)
        {
			Message = "hello";
            SendCommand = new DelegateCommand(() =>
			{
                //订阅一个消息回调函数(不带订阅过滤器)
                //eventAggregator.GetEvent<MessageEvent>().Subscribe(OnMessageReceived);
                //订阅一个消息回调函数(只接受hello作为回调函数参数的发布信息)
                eventAggregator.GetEvent<MessageEvent>().Subscribe(OnMessageReceived, ThreadOption.PublisherThread, false, (x) => { return x == "hello"; });
            });
            TriggerCommand = new DelegateCommand(() =>
            {
                //发布消息触发消息回调(hello作为回调函数的参数)
                eventAggregator.GetEvent<MessageEvent>().Publish("hello");
            });
            //使用他可以去订阅一些消息
            this.eventAggregator = eventAggregator;
        }

        //针对订阅设置的消息回调函数
        public void OnMessageReceived(string messageFromMessageEvent)
        {
            Message += messageFromMessageEvent + "\r\n";
        }

        public string Message
		{
			get { return message; }
			set { message = value; RaisePropertyChanged(); }
		}

		public DelegateCommand SendCommand { get; private set; }

        public DelegateCommand TriggerCommand { get; private set; }

    }
    //自定义一个消息类型,他的消息是一个字符串
    public class MessageEvent : PubSubEvent<String>{ }

}

public class ModuleAModule : IModule
{
  public void OnInitialized(IContainerProvider containerProvider)
  {

  }

  public void RegisterTypes(IContainerRegistry containerRegistry)
  {
    //添加别名 "CustomName"
    containerRegistry.RegisterForNavigation<ViewA>("CustomName");
    //默认名称 "ViewB"
    containerRegistry.RegisterForNavigation<ViewB>();
  }
}

public class ModuleAModule : IModule
   {
       public void OnInitialized(IContainerProvider containerProvider)
       {

       }

       public void RegisterTypes(IContainerRegistry containerRegistry)
       {
           //指定ViewModel
           containerRegistry.RegisterForNavigation<ViewA, ViewAViewModel>();
           //指定ViewModel并且添加别名
           containerRegistry.RegisterForNavigation<ViewB, ViewBViewModel>("CustomName");
       }
   }

IRegionManager regionManager = …;
regionManager.RequestNavigate("RegionName", "ViewName");

//第一种方式
var param = new NavigationParameters();
//键值对形式
param.Add("Parameter", param);
_regionManger.RequestNavigate("RegionName", "ViewName", param);

//第二种方式
//类似URL地址传递参数
_regionManger.RequestNavigate("RegionName", "ViewName?id=1&Name=xiaoming");

 public void OnNavigatedTo(NavigationContext navigationContext)
 {

 }

public bool IsNavigationTarget(NavigationContext navigationContext)
{
  return true;
}

public void OnNavigatedFrom(NavigationContext navigationContext)
{

}

public void OnNavigatedTo(NavigationContext navigationContext)
{
  var id = navigationContext.Parameters.GetValue<int>("id");
  var name = navigationContext.Parameters["Name"].ToString();
}

public void ConfirmNavigationRequest(NavigationContext navigationContext, Action<bool> continuationCallback)
{
  bool result = true;

  if (MessageBox.Show("确认导航?", "温馨提示", MessageBoxButton.YesNo) == MessageBoxResult.No)
    result = false;

  //通过回调当前返回的确认结果,决定是否启动该导航
  continuationCallback(result);
}
//返回true表示允许导航,返回false表示不允许导航

using Prism.Ioc;
using System.Windows;
using testNavigation.Views;

namespace testNavigation
{
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App
    {
        protected override Window CreateShell()
        {
            return Container.Resolve<MainWindow>();
        }

        protected override void RegisterTypes(IContainerRegistry containerRegistry)
        {
            //此处要注册各种资源
            //默认名为ViewA
            //containerRegistry.RegisterForNavigation<ViewA>();
            //起名方式
            containerRegistry.RegisterForNavigation<ViewA>("PageA");
            containerRegistry.RegisterForNavigation<ViewB>();
        }
    }
}

using Prism.Commands;
using Prism.Mvvm;
using Prism.Regions;
using System.Runtime.CompilerServices;

namespace testNavigation.ViewModels
{
    public class MainWindowViewModel : BindableBase
    {
        private string _title = "Prism Application";
        public string Title
        {
            get { return _title; }
            set { SetProperty(ref _title, value); }
        }

        private readonly IRegionManager regionManager;
        //用于记录日志情况
        IRegionNavigationJournal journal;

        public DelegateCommand OpenACommand { get; set; }
        public DelegateCommand OpenBCommand { get; set; }
        public DelegateCommand GoBackCommand { get; set; }
        public DelegateCommand GoForwordCommand { get; set; }

        public MainWindowViewModel(IRegionManager regionManager)
        {
            OpenACommand = new DelegateCommand(OpenA);
            OpenBCommand = new DelegateCommand(OpenB);
            GoBackCommand = new DelegateCommand(GoBack);
            GoForwordCommand = new DelegateCommand(GoForword);
            this.regionManager = regionManager;
        }

        private void OpenA()
        {

            //传递参数给ViewA
            NavigationParameters param = new NavigationParameters();
            //参数传递的方式是通过键值对
            param.Add("Value", "Hello");
            //导航到ViewA(带参数)
            //regionManager.RequestNavigate("ContentRegion", nameof(Views.ViewA),param);
            //使用字符串导航(带参数)
            //regionManager.RequestNavigate("ContentRegion", "PageA",param);
            //传递参数的另一种写法(类似html的写法)   顺便加上了获取上下文日志
            regionManager.RequestNavigate("ContentRegion", $"PageA?Value=Hello1", arg =>
            {
                //导航后拿到上下文日志
                journal = arg.Context.NavigationService.Journal;
            });
        }

        private void OpenB()
        {
            //导航到ViewB(第三个参数设置导航完成的时候触发回调函数)
            regionManager.RequestNavigate("ContentRegion", nameof(Views.ViewB), arg =>
            {
                //导航后拿到上下文日志
                journal = arg.Context.NavigationService.Journal;
            });
        }

        private void GoBack()
        {
          	//向后导航
            journal.GoBack();
        }

        private void GoForword()
        {
          	//向前导航
            journal.GoForward();
        }

    }
}

using Prism.Mvvm;
using Prism.Regions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;

namespace testNavigation.ViewModels
{
    //继承BindableBase用于实现通知,继承INavigationAware用于实现view导航,可以使用IConfirmNavigationRequest代替INavigationAware,就可以多一个ConfirmNavigationRequest方法用于判断是否允许导航(IConfirmNavigationRequest是继承INavigationAware)
    public class ViewAViewModel : BindableBase,IConfirmNavigationRequest
    {
        private string title;

        public string Title
        {
            get { return title; }
            set { title = value; }
        }

        //判断是否允许导航
        public void ConfirmNavigationRequest(NavigationContext navigationContext, Action<bool> continuationCallback)
        {
            bool result = true;
            if(MessageBox.Show("确认导航","温馨提示",MessageBoxButton.YesNo)==MessageBoxResult.No)
                result = false;
            //固定格式
            continuationCallback(result);
        }

        /// <summary>
        /// 重新创建实例的一个判断,如果已经打开过当前实例的话,如果打开过还返回一个true的话,他会创建一个新的实例覆盖原来的
        /// </summary>
        /// <param name="navigationContext"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public bool IsNavigationTarget(NavigationContext navigationContext)
        {
            return true;
        }

        /// <summary>
        /// 导航离开当前页时触发
        /// </summary>
        /// <param name="navigationContext"></param>
        /// <exception cref="NotImplementedException"></exception>
        public void OnNavigatedFrom(NavigationContext navigationContext)
        {
            
        }

        /// <summary>
        /// 导航完成前,接收用户传递的参数以及是否允许导航等控制
        /// </summary>
        /// <param name="navigationContext"></param>
        /// <exception cref="NotImplementedException"></exception>
        public void OnNavigatedTo(NavigationContext navigationContext)
        {
            //接收Value键对应的值(string类型)
            title = navigationContext.Parameters.GetValue<string>("Value");
        }
    }
}

public interface IDialogAware
{
  string Title { get; }
  event Action<IDialogResult> RequestClose;
  bool CanCloseDialog();
  void OnDialogClosed();
  void OnDialogOpened(IDialogParameters parameters);
}

using Prism.Commands;
using Prism.Mvvm;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace testDialog.ViewModels
{
    public class MsgViewModel : BindableBase,IDialogAware
    {
        public string Title{ set; get; }

        public event Action<IDialogResult> RequestClose;

        public DelegateCommand OkCommand { get; set; }
        public DelegateCommand CancleCommand { get; set; }

        public MsgViewModel()
        {
            OkCommand = new DelegateCommand(() =>
            {
                //成功时构造返回结果返回出去(也是键值对)
                DialogParameters param = new DialogParameters();
                param.Add("Value", Title);
                RequestClose?.Invoke(new DialogResult(ButtonResult.OK, param));
            });
            CancleCommand = new DelegateCommand(() =>
            {
                RequestClose?.Invoke(new DialogResult(ButtonResult.No));
            });
        }

        //是否允许关闭当前窗口
        public bool CanCloseDialog()
        {
            return true;    
        }

        //关闭时触发
        public void OnDialogClosed()
        {
            
        }

        //打开前触发(用于接受参数)
        public void OnDialogOpened(IDialogParameters parameters)
        {
            Title = parameters.GetValue<string>("Value");
        }
    }
}

protected override void RegisterTypes(IContainerRegistry containerRegistry)
{
  //三选一:
  //仅注册视图
  containerRegistry.RegisterDialog<MessageDialog>();
  //注册视图时绑定VM
  containerRegistry.RegisterDialog<MessageDialog, MessageDialogViewModel>();
  //添加别名
  containerRegistry.RegisterDialog<MessageDialog>("DialogName");
}

private readonly IDialogService dialogService;

private void ShowDialog()
{
  DialogParameters keys = new DialogParameters();
  keys.Add("message", "Hello,Prism!");

  dialogService.ShowDialog("MessageDialog", keys, arg =>
                           {

                           });
}

using Prism.Commands;
using Prism.Mvvm;
using Prism.Services.Dialogs;
using System.Windows;
using testDialog.Views;

namespace testDialog.ViewModels
{
    public class MainWindowViewModel : BindableBase
    {
        public DelegateCommand ShowDialogCommand {  get; private set; }

        //对话框服务
        private readonly IDialogService dialog;

        private string _title = "Prism Application";
        public string Title
        {
            get { return _title; }
            set { SetProperty(ref _title, value); }
        }

        //增加IDialogService参数
        public MainWindowViewModel(IDialogService dialog)
        {
            ShowDialogCommand = new DelegateCommand(ShowDialog);
            this.dialog = dialog;
        }

        private void ShowDialog()
        {
            //添加参数
            DialogParameters param = new DialogParameters();
            param.Add("Value", "Hello");
            //显示对话框(不带参数)
            //dialog.ShowDialog("dialogView");
            //显示对话框阳
            dialog.ShowDialog("dialogView",param, arg =>
            {
                if(arg.Result == ButtonResult.OK)
                {
                    //获取返回的结果
                    MessageBox.Show(arg.Parameters.GetValue<string>("Value"));
                }
            });
        }
    }
}

public static void ShowNotification(this IDialogService dialogService,
string message, Action<IDialogResult> callback)
{
var p = new DialogParameters();
p.Add("message", message);
dialogService.ShowDialog(“NotificationDialog", p, callback);
}

private void OpenDialog()
{
    DialogParameters parameters = new DialogParameters();
    parameters.Add("initialValue", "默认文本"); // 传递初始值
    dialogService.ShowDialog("UserInputDialog", parameters, result =>
    {
        if (result.Result == ButtonResult.OK)
        {
            string userInput = result.Parameters.GetValue<string>("userInput");
            // 处理用户输入的数据
        }
    });
}
//也可以简写成:
 dialogService.ShowDialog("SelectLinkPointDialogView", new DialogParameters
 {
     { "input", "测试输入内容111" },
 }, r =>
 {
     if (r.Result == ButtonResult.OK)
     {
         var values = r.Parameters.GetValue<string>("output");
     }
 });

public class UserInputDialogViewModel : BindableBase,IDialogAware
{
  
   			public string Title => "对话框标题";
  
        //是否允许关闭当前窗口
        public bool CanCloseDialog()
        {
            return true;    
        }

        //关闭时触发
        public void OnDialogClosed()
        {
            //在关闭前提供了一个时机点来做一些处理
        }

        //打开前触发(用于接受参数)
        public void OnDialogOpened(IDialogParameters parameters)
        {
           if (parameters.ContainsKey("Value"))
           		Title = parameters.GetValue<string>("Value");
        }
  			
  			//请求退出,给外界提供的获取接口
  			public event Action<IDialogResult> RequestClose;
  
  		//可以在对话框中添加按钮,按钮绑定到命令
  		private DelegateCommand<string> _closeDialogCommand;
			public DelegateCommand<string> CloseDialogCommand =>
    _closeDialogCommand ?? (_closeDialogCommand = new DelegateCommand<string>(ExecuteCloseDialogCommand));

      void ExecuteCloseDialogCommand(string parameter)
      {
        	var dialogResult = new DialogResult(ButtonResult.OK);
        	dialogResult.Parameters.Add("values", new Dictionary<string, object>(_inputValues));
        	RequestClose?.Invoke(dialogResult); //确保对话框是通过调用RequestClose事件来关闭的，而不是通过直接关闭窗口的方式。这样可以确保DialogResult被正确传递
      }
}

protected override void RegisterTypes(IContainerRegistry containerRegistry)
{
    containerRegistry.RegisterDialog<UserInputDialog, UserInputDialogViewModel>("UserInputDialog");
}

public class UserInputResult
{
    public string InputText { get; set; }
    public bool IsConfirmed { get; set; }
}

// 在回调中使用
var result = result.Parameters.GetValue<UserInputResult>("result");