C# IRegionManager.RequestNavigate方法代码示例

        public NavigationView(IRegionManager regionManager)
        {
            DataContext = this;

            NavigateStartPage = new DelegateCommand(() =>
            regionManager.RequestNavigate(Regions.MainContent, typeof(StartPageView).FullName));
            NavigateCategories = new DelegateCommand(() =>
            regionManager.RequestNavigate(Regions.MainContent, typeof(CategoriesView).FullName));
            NavigateQuestions = new DelegateCommand(() =>
            regionManager.RequestNavigate(Regions.MainContent, typeof(QuestionsView).FullName));

            InitializeComponent();
        }

 public MenuViewModel(IRegionManager regionManager)
 {
     MenuItems = new ObservableCollection<MenuItem>()
     {
       new MenuItem{Text = "Sorter", Command = new RelayCommand(() => regionManager.RequestNavigate("GenerateRegion", new Uri("")))}
     };
 }

        public QuestionsViewModel(Client client, IRegionManager regionManager)
        {
            AddCategoryCommand = new DelegateCommand(() =>
            regionManager.RequestNavigate(Regions.MainContent, typeof(AddQuestionView).FullName));

            _client = client;
            Questions = _client.Context
                .Questions
                .Expand("Answers")
                .ToArray();

            foreach (var item in Questions.SelectMany(a=>a.Answers))
            {
                client.Context.IgnoreResourceNotFoundException = true;
                try
                {
                    client.Context.LoadProperty(item, "Score");
                }
                catch (DataServiceClientException ex)
                {
                    //Not sure why, but when NotFound then DataServiceClient throws exception
                    //It is normal thing when navigation property = null ergo is NotFound
                    if(!(ex.Message=="NotFound"))
                    {
                        throw;
                    }
                }
            }
        }

        public MainWindowViewModel(IRegionManager regionManager)
        {
            _regionManager = regionManager;

            NavigateCommand = new DelegateCommand<string>(Navigate);

            _regionManager.RequestNavigate(ContentRegionId, "ViewA");
        }

        public MainWindow(IEventAggregator eventAggregator, IRegionManager regionManager, ILoggerFacade logger, AppState state)
        {
            Uri mainPage;

            InitializeComponent();

            _logger = logger;

            // Subscribes to the CloseGameEvent and closes the window when triggered.
            eventAggregator.GetEvent<CloseGameEvent>().Subscribe(a => Close());

            if (state.Mode == ScreenMode.FullScreen)
            {
                WindowStyle = WindowStyle.None;
                WindowState = WindowState.Maximized;
                Focus();
            }

            if (string.IsNullOrEmpty(state.Language))
            {
                mainPage = new Uri("/PageSelectLanguage", UriKind.Relative);
            }
            else
            {
                _dictionary.SetCultureCommand.Execute(state.Language);
                mainPage = new Uri("/PageStartMenu", UriKind.Relative);
            }

            Width = SystemParameters.PrimaryScreenWidth;
            Height = SystemParameters.PrimaryScreenHeight;

            Loaded += (o, args) =>
            {
                _logger.Log("Navigating to default header and start menu.", Category.Debug, Priority.Medium);
                regionManager.RequestNavigate("HeaderContentRegion", new Uri("/PageHeader", UriKind.Relative));
                regionManager.RequestNavigate("MainContentRegion", mainPage);
            };

            Closing += (o, args) =>
            {
                state.SaveState();
            };

            //Setup.SetupGame();
        }

        public MainWindowViewModel(IRegionManager regionManager, RegionNavigationService regionNavigationService)
        {
            FlyoutConsoleCommand = new DelegateCommand(FlyoutConsole);
            GoBackCommand = new DelegateCommand(GoBack);
            _regionManager = regionManager;
            _regionNavigationService = regionNavigationService;

            Uri PlugInHomeURI = new Uri("StartScreenView", UriKind.Relative);
            _regionManager.RequestNavigate("ContentRegion", PlugInHomeURI);
        }

        public EngineeringViewModel(IUnityContainer container, IRegionManager manager)
        {
            _systems = new List<BaseObject>();

            _container = container;
            _regionManager = manager;
            _planObjects = container.Resolve<PlanObjectsRepository>();

            Title = "Инженерные системы";
            NavigateCommand = new DelegateCommand(() => _regionManager.RequestNavigate(RegionNames.MainRegion, new Uri(BuildingViewNames.BuildingView, UriKind.Relative)));
        }

 public CSRNavigationViewModel(IRegionManager regionManager, IEventAggregator eventAggregator)
 {
     this._regionManager = regionManager;
     _loadCommand = new DelegateCommand<object>(ExecuteMethod, CanExecute);
     _loadContactCommand = new DelegateCommand<object>(LoadContact, CanExecute);
     _loadCustomerCommand = new DelegateCommand<object>(LoadCustomer, CanExecute);
     _searchCustNoCommand = new DelegateCommand<object>(SearchCustNo, CanLoad);
     _deleteCustomerCommand = new DelegateCommand<object>(DeleteCustomer, CanLoad);
     _nextCommand = new DelegateCommand<object>(Next, CanLoad);
     _previousCommand = new DelegateCommand<object>(Previous, CanLoad);
     _lastCommand = new DelegateCommand<object>(Last, CanLoad);
     _firstCommand = new DelegateCommand<object>(First, CanLoad);
     _saveCustDetailsCommand = new DelegateCommand<object>(SaveCustDetails, CanSave);
     Uri SearchURI = new Uri("/SearchView", UriKind.Relative);
     _regionManager.RequestNavigate("ModuleRegion", SearchURI);
     _eventAggregator = eventAggregator;
     _user = regionManager.Regions["MainContentRegion"].Context as User;
     CustomersLoadedEvent custloadevent = _eventAggregator.GetEvent<CustomersLoadedEvent>();
     custloadevent.Subscribe(CustomersEventHandler);
     SearchCustomerSelectedEvent customerSelectedEvent = _eventAggregator.GetEvent<SearchCustomerSelectedEvent>();
     customerSelectedEvent.Subscribe(CustomerSelectedEventHandler);
     ClearSearch();
     ClearTopSearch();
 }

 public BazSidebarViewModel(IRegionManager regionManager)
 {
     ShowBaz = new DelegateCommand(() => regionManager.RequestNavigate("MainRegion", "BazView"));
 }

 protected CategoryMenuItem(IRegionManager regionManager, string categoryContractName)
     : this(() => regionManager.RequestNavigate(RegionNames.ContentRegion, categoryContractName))
 {
 }

        public MainWindow(IRegionManager regionManager)
        {
            InitializeComponent();

            Loaded += (sender, args) => regionManager.RequestNavigate("MainRegion", typeof (IAnimeListView).FullName);
        }

        /// <summary>
        /// Navigates the specified region manager.
        /// </summary>
        /// <param name="regionManager">The region manager.</param>
        /// <param name="regionName">Name of the region.</param>
        /// <param name="viewName">Name of the view.</param>
        /// <param name="commandName">Name of the command.</param>
        /// <param name="parameters">The parameters.</param>
        public void Navigate(
            IRegionManager regionManager,
            string regionName,
            string viewName,
            string commandName = null,
            params KeyValuePair<string, string>[] parameters )
        {
            var uriQuery = new UriQuery ();
            if ( commandName != null )
            {
                uriQuery.Add ( "CommandName", commandName );
            }
            foreach ( var parameter in parameters.Where ( parameter => parameter.Value != null ) )
            {
                uriQuery.Add ( parameter.Key, parameter.Value );
            }

            var uri = new Uri ( viewName + uriQuery, UriKind.Relative );

            regionManager.RequestNavigate ( regionName, uri, NavigationCallBack );
        }

 public FooSidebarViewModel(IRegionManager regionManager)
 {
     ShowFoo = new DelegateCommand(() => regionManager.RequestNavigate("MainRegion", "FooView"));
 }

        public LoginViewModel(IChatHubProxy proxy, IRegionManager rm)
        {
            _proxy = proxy;

            Login = new DelegateCommand(async () =>
            {
                IsLoggingIn = true;
                try
                {
                    await proxy.Login(Username);
                }
                finally
                {
                    IsLoggingIn = false;
                }

            }, () => IsConnected && !IsLoggingIn && !String.IsNullOrWhiteSpace(Username));

            proxy.Connected = (detail, details) => rm.RequestNavigate(RegionNames.MainRegion, new Uri("ChatView", UriKind.Relative));


            Reconnect = new DelegateCommand(async () => await Connect(), () => !IsConnected && !IsConnecting);

            Reconnect.Execute();
        }

 public ChatViewModel(IRegionManager rm)
 {
     _rm = rm;
     NavigateTo = new DelegateCommand(() => _rm.RequestNavigate(RegionNames.MainRegion, new Uri("LoginView", UriKind.Relative)));
 }