public void DisplayViewInSplitPanel(string url, NavigationParameters parameter)
        {
            Action operation = () => 
            {
                var uri = new Uri(url, UriKind.Relative);
                _loadedEdgePanel = (FrameworkElement)Application.LoadComponent(uri);

                _loadedEdgePanel.Loaded += (sender, evt) => SplitterPanelLoaded(sender, evt, parameter);
                _splitWindowContent.Children.Clear();
                var contains = _splitWindowContent.Children.Contains(_loadedEdgePanel);
                _splitWindowContent.Children.Add(_loadedEdgePanel);

                // Force the metro window to calculate the size of the user control.
                _loadedEdgePanel.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
                _splitWindowContent.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
                _splitWindow.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));

                DisplayEdgePanel();
            };

            if (_isEdgePanelOpen)
            {
                HideEdgePanel(operation);
            }
            else
            {
                operation();
            }
        }

        public override void OnNavigatedFrom(NavigationParameters parameters)
        {
            Loader.CancelLoading();
            ListLoader.CancelLoading();

            base.OnNavigatedFrom(parameters);
        }

        /// <summary>
        /// Navigates to the most recent entry in the back navigation history by popping the calling Page off the navigation stack.
        /// </summary>
        /// <param name="parameters">The navigation parameters</param>
        /// <param name="useModalNavigation">If <c>true</c> uses PopModalAsync, if <c>false</c> uses PopAsync</param>
        /// <param name="animated">If <c>true</c> the transition is animated, if <c>false</c> there is no animation on transition.</param>
        /// <returns>If <c>true</c> a go back operation was successful. If <c>false</c> the go back operation failed.</returns>
        public virtual async Task<bool> GoBackAsync(NavigationParameters parameters = null, bool? useModalNavigation = null, bool animated = true)
        {
            try
            {
                var page = GetCurrentPage();
                var segmentParameters = GetSegmentParameters(null, parameters);

                var canNavigate = await CanNavigateAsync(page, segmentParameters);
                if (!canNavigate)
                    return false;

                bool useModalForDoPop = UseModalNavigation(page, useModalNavigation);
                Page previousPage = GetOnNavigatedToTarget(page, useModalForDoPop);

                OnNavigatedFrom(page, segmentParameters);

                var poppedPage = await DoPop(page.Navigation, useModalForDoPop, animated);
                if (poppedPage != null)
                {
                    OnNavigatedTo(previousPage, segmentParameters);
                    return true;
                }
            }
            catch (Exception e)
            {
                _logger.Log(e.ToString(), Category.Exception, Priority.High);
                return false;
            }

            return false;
        }

        void Navigate()
        {
            NavigationParameters parameters = new NavigationParameters();
            parameters.Add("message", "Message from MainPage");

            _navigationService.Navigate("ViewA", parameters);
        }

        /// <summary>
        /// Initiates navigation to the target specified by the <paramref name="target"/>.
        /// </summary>
        /// <param name="navigation">The navigation object.</param>
        /// <param name="target">A string that represents the target where the region will navigate.</param>
        /// <param name="navigationParameters">An instance of NavigationParameters, which holds a collection of object parameters.</param>
        public static void RequestNavigate(this INavigateAsync navigation, string target, NavigationParameters navigationParameters)
        {
            if (navigation == null) throw new ArgumentNullException("navigation");
            if (target == null) throw new ArgumentNullException("target");

            navigation.RequestNavigate(new Uri(target, UriKind.RelativeOrAbsolute), nr => { }, navigationParameters);
        }

        /// <summary>
        /// Initiates navigation to the target specified by the <paramref name="target"/>.
        /// </summary>
        /// <param name="navigation">The navigation object.</param>
        /// <param name="target">A Uri that represents the target where the region will navigate.</param>
        /// <param name="navigationParameters">An instance of NavigationParameters, which holds a collection of object parameters.</param>
        public static void RequestNavigate(this INavigateAsync navigation, Uri target, NavigationParameters navigationParameters)
        {
            if (navigation == null)
                throw new ArgumentNullException(nameof(navigation));

            navigation.RequestNavigate(target, nr => { }, navigationParameters);
        }

        public void OnNavigatedTo(NavigationParameters parameters)
        {
            Debug.WriteLine("-------------MainPageViewModel----------OnNavigatedTo <--");

            if (parameters.ContainsKey("title"))
                Title = (string)parameters["title"] + " and Prism";
        }

        private void Navigate()
        {
            var navParams = new NavigationParameters();
            navParams.Add("timestamp", DateTime.Now);

            _navigationService.Navigate("ViewB", navParams);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="NavigationContext"/> class for a region name and a 
 /// <see cref="Uri"/>.
 /// </summary>
 /// <param name="navigationService">The navigation service.</param>
 /// <param name="navigationParameters">The navigation parameters.</param>
 /// <param name="uri">The Uri.</param>
 public NavigationContext(IRegionNavigationService navigationService, Uri uri, NavigationParameters navigationParameters)
 {
     NavigationService = navigationService;
     Uri = uri;
     Parameters = uri != null ? UriParsingHelper.ParseQuery(uri) : null;
     GetNavigationParameters(navigationParameters);
 }

        public async Task Init(NavigationParameters parameters)
        {
            bool successful = await SafeOperation(
                TaskEx.Run(async () => Sponsor = await _campService.GetSponsor(parameters.Id)));

            FinishedLoading(successful);
        }

 public void WhenGivenDuplicateParametersThrowsArgumentException()
 {
     Assert.Throws<ArgumentException>(() =>
     {
         var parameters = new NavigationParameters(_uri);
         parameters.Add("id", 3);
     });            
 }

        public override void OnNavigatedTo(NavigationParameters parameters)
        {
            base.OnNavigatedTo(parameters);
            Issue = new IssueViewModel(parameters[Constants.IssueParameterName] as IIssue);
            _repo = parameters[Constants.RepoParameterName] as IRepo;

            Title = string.Format(LogWork.IssueTitle, Issue.Number);
        }

        public void AddCustomerHandler()
        {
            var q = new NavigationParameters();
            q.Add("id",-1);
            regionManager.RequestNavigate(RegionNames.MainRegion, "CustomerAddUpdateView" + q.ToString());
            

        }

 private void Click()
 {
     var parameters = new NavigationParameters();
     parameters.Add("Message", "A message from ViewA");
     
     //uses the overload to navigate using a class as the key
     //when navigating within a NavigationPage, set useModalNavigation = false
     NavigationService.Navigate<ViewCViewModel>(parameters);
 }

        public bool CanNavigate(NavigationParameters parameters)
        {
            OnConfirmNavigationCalled = true;

            if (parameters.ContainsKey("canNavigate"))
                return (bool)parameters["canNavigate"];

            return true;
        }

 public void ParametersParsedFromQueryWithNoQuestionMarkDelimiter()
 {
     var parameters = new NavigationParameters(_uriWithNoQuestionMarkDelimiter);
     Assert.Equal(2, parameters.Count);
     Assert.True(parameters.ContainsKey("id"));
     Assert.Equal("3", parameters["id"]);
     Assert.True(parameters.ContainsKey("name"));
     Assert.Equal("brian", parameters["name"]);
 }

        public void OnNavigatedTo(NavigationParameters parameters)
        {
            if (parameters == null)
                return;

            var selectedItemName = (string)parameters["selectedItem"];

            SelectedPage = Pages.Where(p => p.Name == selectedItemName).FirstOrDefault();
        }

        public override async void OnNavigatedTo(NavigationParameters parameters)
        {
            base.OnNavigatedTo(parameters);

            _repo = parameters[Constants.RepoParameterName] as IRepo;
            Title = _repo.Name;

            await LoadIssuesAsync(Loader);
        }

        void EditUserRole()
        {
            var selection = SelectedItems.Select(x => x.Id.ToString(CultureInfo.InvariantCulture));

            var sb = new StringBuilder();
            sb.Append(UmsViews.EditUserRoleView);
            var query = new NavigationParameters {{"Selection", string.Join(",", selection)}};
            sb.Append(query);
            _regionManager.RequestNavigate(Regions.TagModulesRegion, new Uri(sb.ToString(), UriKind.Relative));
        }

        public override async void OnNavigatedTo(NavigationParameters parameters)
        {
            base.OnNavigatedTo(parameters);

            _issue = parameters[Constants.IssueParameterName] as IIssue;
            _repo = parameters[Constants.RepoParameterName] as IRepo;

            Title = string.Format(Resources.Strings.WorkLogs.IssueTitle, _issue?.Number);

            await LoadWorkLogsAsync(Loader);
        }