WPF自定义导航

最新推荐文章于 2025-04-29 16:47:19 发布
最新推荐文章于 2025-04-29 16:47:19 发布
阅读量960 收藏 2
点赞数
分类专栏： WPF 文章标签： wpf microsoft
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pw8992134/article/details/121175068
版权

1.导航接口

/// <summary>
    /// 自定义导航服务接口
    /// </summary>
    public interface ICustomNavigationService
    {
        /// <summary>
        /// 记录不同页面容器的当前页面键集合
        /// </summary>
        List<(string pageHostName, ApplicationPage page)> CurrentPageKeyList
        {
            get;
        }

        /// <summary>
        /// 回退到上一页
        /// </summary>
        void GoBack(string pageHostName);

        /// <summary>
        /// 导航到指定键页面
        /// </summary>
        /// <param name="pageHostName">容器名称</param>
        /// <param name="pageKey">页面ApplicationPage类型键</param>
        void NavigateTo(string pageHostName, ApplicationPage pageKey);

        /// <summary>
        /// 导航到指定键页面并且传递参数
        /// </summary>
        /// <param name="pageHostName">容器名称</param>
        /// <param name="pageKey">页面ApplicationPage类型键</param>
        /// <param name="parameter">页面间传递的参数:一般情况下，请直接在IOC容器中获取ViewModel并且传递值</param>
        void NavigateTo(string pageHostName, ApplicationPage pageKey, object parameter);
    }

2.实现

public class NavigationService : ICustomNavigationService
    {
        /// <summary>
        /// 锁对象
        /// </summary>
        private object _navLock = new object();

        /// <summary>
        /// 缓存页面键值对
        /// </summary>
        private Dictionary<ApplicationPage, BasePage> _navigationDic;

        /// <summary>
        /// 记录历史页面字典栈
        /// </summary>
        private Dictionary<string, Stack<ApplicationPage>> _historyStack;

        /// <summary>
        /// 记录不同页面容器的当前页面键集合
        /// </summary>
        public List<(string pageHostName, ApplicationPage page)> CurrentPageKeyList { get; set; }

        /// <summary>
        /// 构造器
        /// </summary>
        public NavigationService()
        {
            _navigationDic = new Dictionary<ApplicationPage, BasePage>();
            _historyStack=new Dictionary<string, Stack<ApplicationPage>>();
            CurrentPageKeyList = new List<(string, ApplicationPage)>();
        }

        /// <summary>
        /// 回退到上一页
        /// </summary>
        public void GoBack(string pageHostName)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 导航到指定键页面
        /// </summary>
        /// <param name="pageHostName">容器名称</param>
        /// <param name="pageKey">页面ApplicationPage类型键</param>
        public void NavigateTo(string pageHostName, ApplicationPage pageKey)
        {
            NavigateTo(pageHostName, pageKey, null);
        }

        /// <summary>
        /// 导航到指定键页面并且传递参数
        /// </summary>
        /// <param name="pageHostName">容器名称</param>
        /// <param name="pageKey">页面ApplicationPage类型键</param>
        /// <param name="parameter">页面间传递的参数:一般情况下，请直接在IOC容器中获取ViewModel并且传递值</param>
        public void NavigateTo(string pageHostName, ApplicationPage pageKey, object parameter)
        {
            lock (_navLock)
            {
                //导航页末调用Configure方法配置
                if (!_navigationDic.ContainsKey(pageKey))
                {
                    throw new ArgumentException("This key is not configured!");
                }

                //找到页面容器
                List<PageHost> pageHosts = new List<PageHost>();
                Application.Current.MainWindow.FindAllChilds<PageHost>(ref pageHosts);

                var pageHost = pageHosts.FirstOrDefault(t => t.Name == pageHostName);

                if (pageHost == null)
                {
                    throw new Exception("PageHost is not Configured!");
                }

                //当前页列表未记录当前键，初始化当前键与历史列表
                if (!CurrentPageKeyList.Any(t => t.pageHostName == pageHostName))
                {
                    CurrentPageKeyList.Add((pageHostName, pageKey));

                    _historyStack.Add(pageHostName, new Stack<ApplicationPage>());
                }
                else
                {
                    //将当前键加入历史列表栈
                    _historyStack[pageHostName].Push(CurrentPageKeyList.First(t => t.pageHostName == pageHostName).page);
                    CurrentPageKeyList.Remove(CurrentPageKeyList.First(t => t.pageHostName == pageHostName));
                    CurrentPageKeyList.Add((pageHostName, pageKey));
                }

                //获取页面框架
                var newPageFrame = pageHost.newPage;
                var oldPageFrame = pageHost.oldPage;

                //获取xaml传入的当前viewmodel
                var currentPageViewModel = pageHost.CurrentPageViewModel;

                //在页未改变情况下只更新ViewModel
                if (newPageFrame.Content is BasePage page && page == _navigationDic[pageKey])
                     page.ViewModelObject= currentPageViewModel;

                var oldPageContent = newPageFrame.Content;
                newPageFrame.Content = null;
                oldPageFrame.Content = oldPageContent;

                //动画效果
                if (oldPageContent is BasePage oldPage)
                {
                    oldPage.ShouldAnimateOut = true;

                    Task.Delay((int)(oldPage.SlideSeconds * 1000)).ContinueWith((t) =>
                    {
                        Application.Current.Dispatcher.Invoke(() => oldPageFrame.Content = null);
                    });
                }

                //切换页面
                BasePage showPage = _navigationDic[pageKey];
                showPage.ViewModelObject = currentPageViewModel;
                showPage.ExtraData = parameter;
                newPageFrame.Content = showPage;
            }
        }

        /// <summary>
        /// 配置页面键值对
        /// </summary>
        /// <param name="pageKey">页面ApplicationPage类型键</param>
        /// <param name="basePage">页面</param>
        /// <exception cref="ArgumentException">键或者值被引用过抛出异常</exception>
        public void Configure(ApplicationPage pageKey,BasePage basePage)
        {
            lock (_navLock)
            {
                if (_navigationDic.ContainsKey(pageKey))
                {
                    throw new ArgumentException("This key is already used:"+pageKey);
                }

                if (_navigationDic.Values.Any(t => t == basePage))
                {
                    throw new ArgumentException("This basepage is already configured with key "+ _navigationDic.First(t => t.Value == basePage).Key);
                }

                _navigationDic.Add(pageKey,basePage);
            }
        }
    }

3.使用mvvmlight自定义viewmodel

public class BaseViewModel:ViewModelBase
    {
        protected object mPropertyValueCheckLock=new object();

        protected async Task RunCommandAsync(Expression<Func<bool>> flagUpdating,Func<Task> action)
        {
            lock (mPropertyValueCheckLock)
            {
                if (flagUpdating.GetPropertyValue())
                {
                    return;
                }

                flagUpdating.SetPropertyValue(true);
            }

            try
            {
                await action();
            }
            finally
            {
                flagUpdating.SetPropertyValue(false);
            }
        }

        protected async Task<T> RunCommandAsync<T>(Expression<Func<bool>> flagUpdating, Func<Task<T>> action,T defaultValue)
        {
            lock (mPropertyValueCheckLock)
            {
                if (flagUpdating.GetPropertyValue())
                {
                    return defaultValue;
                }

                flagUpdating.SetPropertyValue(true);
            }

            try
            {
                return await action();
            }
            finally
            {
                flagUpdating.SetPropertyValue(false);
            }
        }
    }

public static class DependencyObjectHelpers
    {
        public static void FindAllChilds(this DependencyObject d, ref List<DependencyObject> dependencyObjects)
        {
            var count = VisualTreeHelper.GetChildrenCount(d);

            for (int i = 0; i < count; i++)
            {
                DependencyObject dependencyObject = VisualTreeHelper.GetChild(d, i);
                dependencyObjects.Add(dependencyObject);

                FindAllChilds(dependencyObject, ref dependencyObjects);
            }
        }

        public static void FindAllChilds<T>(this DependencyObject d, ref List<T> dependencyObjects) where T:class
        {
            var count = VisualTreeHelper.GetChildrenCount(d);

            for (int i = 0; i < count; i++)
            {
                DependencyObject dependencyObject = VisualTreeHelper.GetChild(d, i);

                if (dependencyObject.GetType() == typeof(T))
                {
                    dependencyObjects.Add(dependencyObject as T);
                }

                FindAllChilds(dependencyObject, ref dependencyObjects);
            }
        }
    }

public enum ApplicationPage
    {
        None=0
    }
`public partial class PageHost : UserControl
    {
        public ApplicationPage CurrentPage
        {
            get { return (ApplicationPage)GetValue(CurrentPageProperty); }
            set { SetValue(CurrentPageProperty, value); }
        }

        public static readonly DependencyProperty CurrentPageProperty =
            DependencyProperty.Register("CurrentPage", typeof(ApplicationPage), typeof(PageHost), new PropertyMetadata(default(ApplicationPage),null, CurrentPagePropertyChanged));

        public BaseViewModel CurrentPageViewModel
        {
            get { return (BaseViewModel)GetValue(CurrentPageViewModelProperty); }
            set { SetValue(CurrentPageViewModelProperty, value); }
        }

        public static readonly DependencyProperty CurrentPageViewModelProperty =
            DependencyProperty.Register("CurrentPageViewModel", typeof(BaseViewModel), typeof(PageHost), new PropertyMetadata(0));

        public PageHost()
        {
            InitializeComponent();

            if (DesignerProperties.GetIsInDesignMode(this))
                newPage.Content = null;
        }

        private static object CurrentPagePropertyChanged(DependencyObject d, object value)
        {
            //ioc navigation

            return value;
        }
    }
```csharp
public class BasePage : UserControl
    {
        #region Private Member

        /// <summary>
        /// The View Model associated with this page
        /// </summary>
        private object mViewModel;

        #endregion

        #region Public Properties

        /// <summary>
        /// The animation the play when the page is first loaded
        /// </summary>
        public PageAnimation PageLoadAnimation { get; set; } = PageAnimation.SlideAndFadeInFromRight;

        /// <summary>
        /// The animation the play when the page is unloaded
        /// </summary>
        public PageAnimation PageUnloadAnimation { get; set; } = PageAnimation.SlideAndFadeOutToLeft;

        /// <summary>
        /// The time any slide animation takes to complete
        /// </summary>
        public float SlideSeconds { get; set; } = 0.4f;

        /// <summary>
        /// A flag to indicate if this page should animate out on load.
        /// Useful for when we are moving the page to another frame
        /// </summary>
        public bool ShouldAnimateOut { get; set; }

        /// <summary>
        /// The View Model associated with this page
        /// </summary>
        public object ViewModelObject
        {
            get => mViewModel;
            set
            {
                // If nothing has changed, return
                if (mViewModel == value)
                    return;

                // Update the value
                mViewModel = value;

                // Fire the view model changed method
                OnViewModelChanged();

                // Set the data context for this page
                DataContext = mViewModel;
            }
        }

        public object ExtraData { get; set; }

        #endregion

        #region Constructor

        /// <summary>
        /// Default constructor
        /// </summary>
        public BasePage()
        {
            // Don't bother animating in design time
            if (DesignerProperties.GetIsInDesignMode(this))
                return;

            // If we are animating in, hide to begin with
            if (PageLoadAnimation != PageAnimation.None)
                Visibility = Visibility.Collapsed;

            // Listen out for the page loading
            Loaded += BasePage_LoadedAsync;
        }

        #endregion

        #region Animation Load / Unload

        /// <summary>
        /// Once the page is loaded, perform any required animation
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void BasePage_LoadedAsync(object sender, System.Windows.RoutedEventArgs e)
        {
            // If we are setup to animate out on load
            if (ShouldAnimateOut)
                // Animate out the page
                await AnimateOutAsync();
            // Otherwise...
            else
                // Animate the page in
                await AnimateInAsync();
        }

        /// <summary>
        /// Animates the page in
        /// </summary>
        /// <returns></returns>
        public async Task AnimateInAsync()
        {
            // Make sure we have something to do
            if (PageLoadAnimation == PageAnimation.None)
                return;

            switch (PageLoadAnimation)
            {
                case PageAnimation.SlideAndFadeInFromRight:

                    // Start the animation
                    await this.SlideAndFadeInAsync(AnimationSlideInDirection.Right, false, SlideSeconds, size: (int)Application.Current.MainWindow.Width);

                    break;
            }
        }

        /// <summary>
        /// Animates the page out
        /// </summary>
        /// <returns></returns>
        public async Task AnimateOutAsync()
        {
            // Make sure we have something to do
            if (PageUnloadAnimation == PageAnimation.None)
                return;

            switch (PageUnloadAnimation)
            {
                case PageAnimation.SlideAndFadeOutToLeft:

                    // Start the animation
                    await this.SlideAndFadeOutAsync(AnimationSlideInDirection.Left, SlideSeconds);

                    break;
            }
        }

        #endregion

        /// <summary>
        /// Fired when the view model changes
        /// </summary>
        protected virtual void OnViewModelChanged()
        {

        }
    }

    /// <summary>
    /// A base page with added ViewModel support
    /// </summary>
    public class BasePage<VM> : BasePage
        where VM : BaseViewModel, new()
    {
        #region Public Properties

        /// <summary>
        /// The view model associated with this page
        /// </summary>
        public VM ViewModel
        {
            get => (VM)ViewModelObject;
            set => ViewModelObject = value;
        }

        #endregion

        #region Constructor

        /// <summary>
        /// Default constructor
        /// </summary>
        public BasePage() : base()
        {
            // If in design time mode...
            if (DesignerProperties.GetIsInDesignMode(this))
                // Just use a new instance of the VM
                ViewModel = new VM();
            else
                // Create a default view model
                ViewModel = SimpleIoc.Default.GetInstance<VM>() ?? new VM();
        }

        /// <summary>
        /// Constructor with specific view model
        /// </summary>
        /// <param name="specificViewModel">The specific view model to use, if any</param>
        public BasePage(VM specificViewModel = null) : base()
        {
            // Set specific view model
            if (specificViewModel != null)
                ViewModel = specificViewModel;
            else
            {
                // If in design time mode...
                if (DesignerProperties.GetIsInDesignMode(this))
                    // Just use a new instance of the VM
                    ViewModel = new VM();
                else
                {
                    // Create a default view model
                    ViewModel = SimpleIoc.Default.GetInstance<VM>() ?? new VM();
                }
            }
        }

        #endregion
    }
WPF自定义导航标签用户控件.CS代码
D&M的博客
08-08 1363
功能实现效果如下： 后台.CS页面代码如下： using System.Windows; using System.Windows.Controls; using System.Windows.Media; namespace WPF_Client.Resources.Controls { /// <summary> /// UCTabItemWithClos...
WPF自定义左侧折叠菜单
11-27
通过以上步骤，我们可以创建出一个功能完备、易于扩展的WPF自定义左侧折叠菜单。在实际项目中，可能还需要考虑其他因素，如国际化支持、无障碍性等，但以上内容已涵盖了实现这一功能的核心技术点。在实践中不断优化...
wpf 导航条控件
11-17
wpf 导航条 自定义控件 ！ NavigationBar
浅谈WPF页间导航
weixin_34387284的博客
12-27 304
使用导航的目的是从一个页面进入到另一个页面。无论是预先决定的线性顺序（向导）还是基于层次的用户驱动程序（大部分网站的形式），或者动态生成的路径，主要有3种方法实现：调用Navigate方法，使用Hyperlinks，使用导航日志。 Navigate方法： 导航容器支持Navigate方法，它允许改变当前页，可以用目标页的示例： View Code 1 ...
WPF 导航
最新发布
weixin_48990772的博客
04-29 1295
在 中添加一个 Frame： 在 后台跳转页面： 比如在 ： ： ：隐藏 Frame 自带的导航栏。：让 Frame 记录自己的导航历史。：Page 保持实例，不每次都重新加载（否则每次跳回来都会重新创建）。 创建一个window窗体把 改为 把.cs 中的类继承改为 ：NavigationWindow 在 xaml 中设置点鼠标击事件在 .cs 中设置事件 UriKind ：是一个枚举，它定义了如何解释 URI 字符串：：指定 URI 是一个绝对路径
WPF/C#：实现导航功能
mingupup的博客
07-18 2555
在WPF中使用导航功能可以使用Frame控件，这是比较基础的一种方法。前几天分享了wpfui中NavigationView的基本用法，但是如果真正在项目中使用起来，基础的用法是无法满足的。今天通过wpfui中的mvvm例子来说明在wpfui中如何通过依赖注入与MVVM模式使用导航功能。实践起来，我个人觉得这个例子中实现导航功能还是有点麻烦的，但我也不知道怎么能更优雅，也是学到了一些东西吧。
WPF 视图导航
weixin_30817749的博客
05-29 222
<Window x:Class="ViewExam.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" ...
WPF Navigation
weixin_30414305的博客
07-31 794
WPF Navigation In 2001, Microsoft published a paper called Inductive User Interface Guidelines. If you have not read this paper, I would suggest doing so. It is largely technology agnostic, and I...
WPF自定义漂亮顶部工具栏 WPF自定义精致最大化关闭工具栏 wpf导航栏自定义 WPF快速开发工具栏
01-08
在WPF应用程序开发中，自定义一个漂亮的顶部工具栏具有多重关键作用，它不仅增强了用户体验，还提升了整体应用的专业性和易用性。以下是对这一功能的详细介绍： 首先，自定义顶部工具栏是用户界面设计的重要组成...
WPF 自定义对话框 超级完美版
09-19
总之，WPF自定义对话框是一个展示UI设计和编程技巧的领域，"超级完美版"提供了一个良好的起点，帮助开发者快速构建出符合应用风格的高质量对话框。通过深入理解和应用这些知识，开发者可以提升用户体验，使应用程序...
WPF自定义导航菜单设计教程
在本篇知识说明中，我们将深入探讨WPF中菜单设计的相关知识点，包括WPF导航样式以及自定义样式的设计方法。 ### WPF 菜单设计 在WPF应用程序中，菜单是一种常见的导航元素，它可以帮助用户快速访问应用程序的不同...
WPF漂亮的导航菜单
11-05
WPF开发的漂亮酷炫的导航菜单实例程序，导航菜单实例注释讲解十分详细。
wpf实现文件夹导航栏
06-13
diy文件夹导航栏。向前 向后 向上 下拉框显示历史功能。
WPF 实现导航通过Frame的Navigate函数实现导航
05-06
打开即可演示，功能简洁明了，适合初学者 Frame的NavigationUIVisibility属性设置为Hidden：
WPF导航菜单-仿OA导航
10-13
用WPF做的，类似TREEVIEW的导航控件。 点击某个标题的时候，自动展开下面的子项列表，同时关闭之前展开的子项列表。
WPF导航（一）
weixin_30678349的博客
12-22 288
Applicantion也能回退的感觉真好。呵呵。 一、Page 这就是能保存导航路径的基本单位。 Title：Navigation中保存的名字 二、宿主 NavigationWindow 和Frame 三、如何记录一个导航 1.NavigateUri变化时，会自动记录，例如： 　　<Hyperlink NavigateUri="Page2.xaml"&g...
WPF中在MVVM模式下实现导航功能
博客
10-17 3357
WPF中在MVVM模式下实现导航功能
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值