【问题标题】:Wpf reusable window model/templateWpf 可重用的窗口模型/模板
【发布时间】:2014-01-06 22:06:23
【问题描述】:

我正在尝试了解和了解更多有关 WPF 的信息。

在一个有 30 个窗口的 WPF 项目中,所有窗口必须有:

  1. 相同的工具栏(带有按钮:新建、编辑、删除、查看和关闭)
  2. 相同的状态栏
  3. 每个窗口必须有一个带有 2 个 TabItem 的 tabcontrol。 第一个 TabItem 的内容可以根据窗口而有所不同。根据窗口,第二个 TabItem 应始终包含具有不同列的数据网格。

“逻辑顺序”是:

  1. 打开窗口
  2. 用户在第一个TabItem中输入参数
  3. 用户点击搜索按钮
  4. 数据显示在datagarid的第二个TabItem中
  5. 用户点击新建/编辑/删除/查看
  6. 显示编辑数据的窗口

只有在网格视图中的一行被选中时,必须启用新建/编辑/查看和删除按钮。 “逻辑顺序”对所有窗口都有效!

在 winform 中,您可以创建一个具有用作模板的结构的表单,并创建 30 个从模型继承的窗口。 通过模板中的自定义事件,您可以了解用户是否在 gridview 中选择了一行,了解用户是否点击了工具栏上的按钮等

例如,当用户点击New按钮时产生“NewItem”事件,该事件为自定义事件,则在继承自模型的表单中接收“NewItem”事件时打开输入表单

你可以在 WPF 中做类似的事情吗?

您可以在 WPF 中创建表单模板并创建从模板继承的窗口吗?

我希望我很清楚,并为我的英语不好感到抱歉

谢谢

【问题讨论】:

  • @franssu 你不知道你在说什么。请立即删除您的评论。这是完全错误的。
  • 实现这一点的最佳方法是在 XAML 中使用单个 Window,同时让每个 DataTemplates 的“可定制部分”,然后为每个创建一个特定的 ViewModel变体,同时保留工具栏按钮等的所有Commands 作为基本 ViewModel 的一部分。我会尽快发布完整的工作示例。

标签: wpf controltemplate


【解决方案1】:

所以为了回答您的部分问题,我会尝试将您的工具栏(搜索、新建、编辑..等)和状态栏提取到 mainwindow.xaml 中。到那时,也许您可​​以执行以下操作:

拥有单独的视图(用户控件 imo),它们将成为主窗口中内容控件的一部分。

<MainWindow>

   <!-- Toolbar -->
   <ContentControl Content="{Binding CurrentTabView}" /> <!-- Where CurrentTabView is of type interface that all your views implement -->

   <!-- Status bar -->

</MainWindow>

视图模型:

Public IView CurrentTabView { get; set; } //All usercontrol viewmodels implement IView

您可能有一个问题: 如果我的工具栏位于主窗口视图模型中,我如何与用于其他视图的其他视图模型通信?

我会按照 MessageSenders/MessageListeners 的方式研究一些东西

SendMessage(MessageTokens.SearchToken, new NotificationEventArgs<bool>(null, true)); 

SimpleMvvmToolKit 有一个很好的消息系统,你的所有视图模型都可以继承。希望这种帮助。

【讨论】:

    【解决方案2】:

    好的,我会尽量提供详细的答案,所以这可能会有点长,但请耐心等待。

    首先,如果您正在使用 WPF,那么将您可能习惯于“传统”技术(例如 winforms)的任何东西都抛在脑后是极其重要的,而要理解并接受The WPF Mentality。

    在 WPF 中,您不要“从基本窗口继承” 来定义应用程序的功能,因为 UI 不是应用程序。 UI 只是让最终用户与应用程序交互的好方法。

    相反,应用程序的交互逻辑和功能体现在一些名为 ViewModels 的类中,它们基本上定义了 UI 公开的所有内容和操作。

    之后,UI 通过DataBinding“连接”到 ViewModel。

    这实现了高度的可重用性、可扩展性、可维护性甚至可测试性,因为它实际上将 UI 与应用程序/业务逻辑和数据完全分离。

    因此,这些是您在 WPF 中执行您所描述的内容所需的基本步骤:

    1 - 基本数据绑定支持

    由于 WPF 中的双向数据绑定需要Property Change Notification,我们要做的第一件事就是创建一个基本的“可绑定”类来支持这个基本功能:

    public class Bindable : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
    
        public void OnPropertyChanged(string propertyName)
        {
            var handler = PropertyChanged;
            if (handler != null)
                handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }
    

    2 - 父/子视图模型

    您的应用程序将要求在基类中定义父 Window 功能,同时为每个特定的 Window 类型留下继承和自定义“子”部分的机会,因此我们将创建一个基本通用 ViewModel 来定义所有通用的可重用功能,同时还定义了一个通用的“子”属性:

    public class ViewModelBase<T>: Bindable where T: Bindable
    {
        private T _child;
        public T Child
        {
            get { return _child; }
            set
            {
                _child = value;
                OnPropertyChanged("Child");
            }
        }
    }
    
    • 注意这种结构是否适合您的要求:

    • 另请注意具有更改通知的属性的基本示例,您在属性设置器中提出OnPropertyChanged()。

    3 - 命令和按钮

    之后,您需要为您的工具栏Buttons 定义基本功能。 与使用传统的 Click 事件处理程序方法不同,它们表现为 Commands,与 UI 解耦,其执行逻辑在 ViewModel 中定义,而不是在后面的代码中定义。

    为此,我们将定义一个基本的可重用DelegateCommand:

    //Dead-simple implementation of ICommand
    //Serves as an abstraction of Actions performed by the user via interaction with the UI (for instance, Button Click)
    public class Command : ICommand
    {
        public Action Action { get; set; }
    
        public void Execute(object parameter)
        {
            if (Action != null)
                Action();
        }
    
        public bool CanExecute(object parameter)
        {
            return IsEnabled;
        }
    
        private bool _isEnabled = true;
        public bool IsEnabled
        {
            get { return _isEnabled; }
            set
            {
                _isEnabled = value;
                if (CanExecuteChanged != null)
                    CanExecuteChanged(this, EventArgs.Empty);
            }
        }
    
        public event EventHandler CanExecuteChanged;
    
        public Command(Action action)
        {
            Action = action;
        }
    }
    

    使用这个命令类,我们现在可以在主 ViewModel 中定义所有命令:

    public class ViewModelBase<T>: Bindable where T: Bindable
    {
        private T _child;
        public T Child...
    
        public Command SearchCommand { get; private set; }
        public Command NewCommand { get; private set; }
        public Command EditCommand { get; private set; }
        public Command ViewCommand { get; private set; }
        public Command DeleteCommand { get; private set; }
    }
    

    这些命令需要Action 委托来指示执行它们时将执行的操作(单击Buttons 时)。请注意我们是如何开始实际定义功能的,而我们甚至还没有触及 UI 的任何部分。

    这是你定义动作的方式:

    public class ViewModelBase<T>: Bindable where T: Bindable
    {
         //... all of the above.
    
        //in the constructor:
        public ViewModelBase()
        {
            SearchCommand = new Command(Search);
            NewCommand = new Command(New);
            //... And so on...
        }
    
        //Actions for the commands:
        private void Search()
        {
            //... your search logic here.
        }
    
        private void New()
        {
            //... your New logic here...
        }
    
        //... And so on...
    }
    

    启用和禁用命令:您还提到在第二个选项卡中会有一个DataGrid,其中将包含搜索结果,这将启用/禁用一些按钮。

    请注意,Command 类定义了 IsEnabled 属性,这反过来引发了 System.Windows.ICommand.CanExecuteChanged 事件。 WPF 的命令引擎能够侦听此事件,并相应地启用/禁用 UI 元素。因此,在您的应用程序中的任何时候,您都可以通过以下方式切换按钮的状态:

    NewCommand.IsEnabled = false; //disables the "New" Button
    DeleteCommand.IsEnabled = true; //enables the "Delete" Button
    

    4 - 数据网格

    这是最有趣的部分。

    抽象地说,DataGrid、ListBox、ListView、ComboBox 和 WPF 中的所有 ItemsControls 都是显示集合中项目的控件,最终允许用户选择一个或多个项目。

    在 WPF 中,通常使用ObservableCollection&lt;T&gt;,因为它是一种专门的集合类型,每当添加/删除/清除项目时都会引发事件。 WPF 的绑定引擎会侦听此类事件并相应地更新 UI。

    由于我们事先不知道 DataGrid 中将显示什么类型的项目,而我们的最终目标是可重用性,现在是时候为我们的父 ViewModelBase 添加另一个泛型类型参数了:

    public class ViewModelBase<T, TItems>: Bindable where T: Bindable where TItems: class
    {
       //... All of the above...
    }
    

    现在我们可以定义我们的 Collection 属性了:

    public class ViewModelBase<T, TItems>: Bindable where T: Bindable where TItems: class
    {
       //... All of the above...
    
        private ObservableCollection<TItems> _searchResults;
        public ObservableCollection<TItems> SearchResults
        {
            get { return _searchResults; }
            private set
            {
                _searchResults = value;
                OnPropertyChanged("SearchResults");
            }
        }
    

    我们还需要一个属性来存储选中的项目,这反过来会导致Buttons 在选中项目时启用,并在清除选择时禁用:

        private TItems _selectedItem;
        public TItems SelectedItem
        {
            get { return _selectedItem; }
            set
            {
                _selectedItem = value;
    
                NewCommand.IsEnabled = value != null;
                ViewCommand.IsEnabled = value != null;
                DeleteCommand.IsEnabled = value != null;
            }
        }
    }
    

    此时,您确实意识到我们实际上在多大程度上“对 UI 进行了编程”,甚至没有接触 UI。上面的代码将在DataGrid 中选择一个项目时启用新建、查看和删除Buttons,否则禁用。然而,所有这些功能都与 UI 完全分离。

    5 - 子小部件(TabItem 1)

    此时,我们有了一个完全通用的、可重用的基本功能,可以适应任何项目类型,还允许将任何子“小部件”放置在父“小部件”中。

    还要注意这比传统的 winforms 方法好一千倍,因为:

    • 1 - 它是可单元测试的。
    • 2 - DataGrid 的 Items 集合实际上是通用的,这意味着您无需使用强制转换或任何其他不良编码做法。
    • 3 - 甚至还没有定义 UI,这意味着您有很大的自定义机会。到目前为止,我们编写的代码will work,无论 UI 是否包含DataGrid,或飞翔的粉红色大象的 3D 投影。

    现在,只需创建将放置在 30 个不同窗口中的子小部件

    比如说,你需要展示这样的东西:

    您需要做的第一件事是为此定义ViewModel,类似于:

    public class PersonViewModel: Bindable
    {
        public string LastName { get; set; }
    
        public string FirstName { get; set; }
    
        public string City { get; set; }
    
        public string PostalCode { get;set; }
    }
    

    请注意,我们不会在此处提出属性更改通知,因为我们实际上并不需要双向数据绑定。 OneWay 就足够了。尽管如此,我们还是继承自 Bindable,因为父 ViewModel 在 T 类型参数中有类型约束。

    那么,你需要Create a UserControl:

    <UserControl x:Class="WpfApplication1.PersonView"
                 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                 xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
                 xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
                 mc:Ignorable="d" 
                 d:DesignHeight="300" d:DesignWidth="300">
        <Grid>
            <Grid.RowDefinitions>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
            </Grid.RowDefinitions>
    
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="100"/>
                <ColumnDefinition/>
            </Grid.ColumnDefinitions>
    
            <Label HorizontalAlignment="Right" Grid.Row="0" Grid.Column="0" Content="Last Name:" />
            <Label HorizontalAlignment="Right" Grid.Row="1" Grid.Column="0" Content="First Name:" />
            <Label HorizontalAlignment="Right" Grid.Row="2" Grid.Column="0" Content="City:" />
            <Label HorizontalAlignment="Right" Grid.Row="3" Grid.Column="0" Content="Postal Code:" />
    
            <TextBox Grid.Row="0" Grid.Column="1" Margin="2" Text="{Binding LastName}"/>
            <TextBox Grid.Row="1" Grid.Column="1" Margin="2" Text="{Binding FirstName}"/>
            <TextBox Grid.Row="2" Grid.Column="1" Margin="2" Text="{Binding City}"/>
            <TextBox Grid.Row="3" Grid.Column="1" Margin="2" Text="{Binding PostalCode}"/>
        </Grid>
    </UserControl>
    

    请注意,您在 WPF 中实际做的最后一件事是创建 UI。

    6 - 数据模板

    为了让 WPF 知道“哪个 View 用于哪个 ViewModel”,您可以在应用程序级资源中定义 DataTemplates,只需打开 App.xaml 并将这些添加到 Application.Resources 中:

    <Application x:Class="WpfApplication1.App"
                 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                 xmlns:local="clr-namespace:WpfApplication1"
                 StartupUri="MainWindow.xaml">
    
        <Application.Resources>
    
            <DataTemplate DataType="{x:Type local:PersonViewModel}">
                <local:PersonView/>
            </DataTemplate>
        </Application.Resources>
    

    请注意,您需要 Import your Namespaces 才能在 XAML 中引用您的类。

    好的,我现在得走了,继续尝试这些步骤。等我有时间再写完。

    【讨论】:

    • @HighScore 你好!高分感谢您的详细回答。我会尽量听从你的建议和建议。不要忘记我的帖子,我正在不耐烦的等待;)谢谢,谢谢...谢谢!卢卡
    • 它看起来和我已经做过的非常相似。干得好!
    猜你喜欢
    • 1970-01-01
    • 1970-01-01
    • 2011-04-09
    • 1970-01-01
    • 2012-09-25
    • 1970-01-01
    • 2010-09-30
    • 1970-01-01
    • 2011-09-05
    相关资源
    最近更新 更多