WPF入门教程系列二十八 ——DataGrid使用示例MVVM模式(6)

见智见仁

WPF入门教程系列目录WPF入门教程系列二——Application介绍WPF入门教程系列三——Application介绍(续)WPF入门教程系列四——Dispatcher介绍WPF入门教程系列五——Window 介绍
WPF入门教程系列十一——依赖属性（一）WPF入门教程系列十五——WPF中的数据绑定(一)   八、在Command中传递参数

7.上面Buttom的Command类就是纯命令，什么参数都不接收，这次的ProvinceChangedCommand类在执行命令的时候，能够传参数！采用泛型的形式，给Action添加泛型参数。
8. 在Visual Studio 2022的解决方案资源管理器中，使用鼠标右键单击“Command”文件夹，在弹出菜单中选择“添加--> 类”，在弹出的“添加新项”对话框中，选择添加 “ProvinceChangedCommand”类，这是一个我们要实现的保存操作指令，然后选择“添加”。ProvinceChangedCommand的具体代码如下：

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
6. using System.Threading.Tasks;
7. using System.Windows.Input;
9. namespace WpfGridDemo.NET7.Command
10. {
11.     public class ProvinceChangedCommand<T> : ICommand
12.     {
13.         /// <summary>
14.         /// 命令能否执行
15.         /// </summary>
16.         readonly Func<bool> _canExecute;
17.         /// <summary>
18.         /// 命令执行的方法
19.         /// </summary>
20.         readonly Action<T> _execute;
22.         /// <summary>
23.         /// 命令的构造函数
24.         /// </summary>
25.         /// <param name="action">命令需执行的方法</param>
26.         /// <param name="canExecute">命令是否可以执行的方法</param>
27.         public ProvinceChangedCommand(Action<T> action, Func<bool> canExecute)
28.         {
29.             _execute = action;
30.             _canExecute = canExecute;
31.         }
33.         /// <summary>
34.         /// 判断命令是否可以执行
35.         /// </summary>
36.         /// <param name="parameter"></param>
37.         /// <returns></returns>
38.         public bool CanExecute(Object parameter)
39.         {
40.             if (_canExecute == null)
41.                 return true;
42.             return _canExecute();
43.         }
45.         /// <summary>
46.         /// 执行命令
47.         /// </summary>
48.         /// <param name="parameter"></param>
49.         public void Execute(Object parameter)
50.         {
51.             _execute((T)parameter);
52.         }
54.         /// <summary>
55.         /// 事件追加、移除
56.         /// </summary>
57.         public event EventHandler CanExecuteChanged
58.         {
59.             add
60.             {
61.                 if (_canExecute != null)
62.                     CommandManager.RequerySuggested += value;
63.             }
64.             remove
65.             {
66.                 if (_canExecute != null)
67.                     CommandManager.RequerySuggested -= value;
68.             }
69.         }
71.     }
72. }
73. void ProviceSelectionChangedExecute(object sender)
74.         {
75.             try
76.             {
77.                 if (sender is ComboBox)
78.                 {
79.                     ComboBox drp=sender as ComboBox;
80.                     ProvinceCode=drp.SelectedValue.ToString();
81.                     GridDbContext db = new GridDbContext();
82.                     var list = db.City.AsTracking().ToList();
83.                     List<City> citys = list.Where(x => x.ProvinceCode == ProvinceCode).ToList();
84.                     cityList = new ObservableCollection<City>();
85.                     if (citys != null)
86.                     {
87.                         citys.ForEach((t) =>
89.                         { cityList.Add(t); }
90.                         );
91.                     }
93.                     var cityCodes = from city in citys
94.                                     select city.Code;
95.                     List<Area> areas = db.Area.AsTracking().ToList().Where(<br>x => cityCodes.Contains(x.CityCode)).ToList();
97.                     areaList = new ObservableCollection<Area>();
98.                     if (areas!=null)
99.                     {
100.                         areas.ForEach((t) =>
102.                         { areaList.Add(t); }
103.                         );
104.                     }
105.                 }
106.             }
107.             catch (Exception ex)
108.             {
109.                 throw ex;
110.             }
111.         }

复制代码

结果如图：我们看到了省份下拉框中已经了省份信息。

 
9.通过绑定依赖属性，实现自动刷新需要实现以下三步：
1.Model继承并实现 INotifyPropertyChanged 接口；
2.数据集合使用ObservableCollection集合；
3.View使用Binding数据对象属性;
如果不行再看看集合在赋值前需要实例化，不然就出不来(必须要同一个源才行)
10. 在Visual Studio 2022中打开MainWindows.xmal文件，并将文件中的代码修改成如下：

1. <Window x:Class="WpfGridDemo.NET7.MainWindow"
2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
4.         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
5.           xmlns:be="http://schemas.microsoft.com/xaml/behaviors"
6.         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
7.         xmlns:local="clr-namespace:WpfGridDemo.NET7"
8.         mc:Ignorable="d"
9.         Title="MainWindow" Height="600" Width="960" Loaded="Window_Loaded" >
10.     <Grid>
11.         <Grid.RowDefinitions>
12.             <RowDefinition Height="100"></RowDefinition>
13.             <RowDefinition Height="*"></RowDefinition>
14.             <RowDefinition Height="25"></RowDefinition>
15.         </Grid.RowDefinitions>
16.         <WrapPanel Grid.Row="0" HorizontalAlignment="Left">
17.             <ComboBox x:Name="cboProvince" DisplayMemberPath="Name" SelectedValuePath="Code" >
19.                 <be:Interaction.Triggers>
21.                     <be:EventTrigger EventName="SelectionChanged">
22.                         <be:InvokeCommandAction Command="{Binding ProviceChangedAction}" <br>CommandParameter="{Binding  ElementName=cboProvince}"/>
23.                     </be:EventTrigger>
24.                 </be:Interaction.Triggers>
26.             </ComboBox>
27.         </WrapPanel>
29.         <DataGrid x:Name="gridArea" Grid.Row="1" ItemsSource="{Binding GridAreaList}" <br>AutoGenerateColumns="False" HorizontalAlignment="Left" VerticalAlignment="Top" <br>SelectedItem="{Binding Path=AreaVM,
30.                                         Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}">
32.             <DataGrid.Columns>
34.                 <DataGridComboBoxColumn Header="城市" Width="120" <br>ItemsSource="{Binding Path=DataContext.GridCityList, <br>RelativeSource={RelativeSource AncestorType={x:Type Window}}}"  <br>x:Name="cboCity" ClipboardContentBinding="{x:Null}"<br> SelectedValuePath="Code" SelectedValueBinding="{Binding Path=CityCode,<br>UpdateSourceTrigger=PropertyChanged}"  <br>DisplayMemberPath="Name" SelectedItemBinding="{x:Null}" />
35.                 <DataGridTextColumn Header="县区镇" Width="*" Binding="{Binding Name}" <br>ClipboardContentBinding="{x:Null}"/>
36.                 <DataGridTextColumn Header="邮编" Width="100"  Binding="{Binding Code}" <br>ClipboardContentBinding="{x:Null}"/>
37.                 <DataGridTextColumn Header="创建时间" Width="160" Binding="{Binding Created}" <br>ClipboardContentBinding="{x:Null}"/>
38.                 <DataGridTextColumn Header="更新时间" Width="160" Binding="{Binding Updated}" <br>ClipboardContentBinding="{x:Null}"/>
39.             </DataGrid.Columns>
40.         </DataGrid>
41.       
43.         <WrapPanel Grid.Row="2">
44.         <Button  x:Name="btnRefresh"  Height="22" Width="120" Click="btnRefresh_Click">刷新</Button>
45. <Button  x:Name="btnSave" Height="22" Width="120" Command="{Binding ClickSaveAction}" >保存</Button>
46.         </WrapPanel>
47.     </Grid>
48. </Window>

复制代码

 
11. 在Visual Studio 2022中打开MainWindowsVM.cs文件，实现下拉框的选择事件的Command命令绑定，将通过Command参数传递过来的省份信息，用于数据查询，同时通知UI界面进行数据刷新。具体如下代码：

1. using Microsoft.EntityFrameworkCore;
2. using System;
3. using System.Collections.Generic;
4. using System.Collections.ObjectModel;
5. using System.ComponentModel;
6. using System.DirectoryServices.ActiveDirectory;
7. using System.Linq;
8. using System.Text;
9. using System.Threading.Tasks;
10. using System.Windows.Controls;
11. using System.Windows.Input;
12. using WpfGridDemo.NET7.Entitys;
14. namespace WpfGridDemo.NET7.ViewModel
15. {
16.     public class MainWindowVM: ViewModelBase
17.     {
18.         public MainWindowVM() {
19.             cityList = new ObservableCollection<City>();
20.             areaList = new ObservableCollection<Area>();
21.         }
22.         private Area m_Area;
23.         /// <summary>
24.         /// 县镇区数据
25.         /// </summary>
26.         public Area AreaVM
27.         {
28.             get { return m_Area; }
29.             set { m_Area = value; }
30.         }
31.         private string m_Province_Code;
32.         /// <summary>
33.         /// 省--代码
34.         /// </summary>
35.         public string ProvinceCode { get => m_Province_Code; set => m_Province_Code = value; }
36.         private ObservableCollection<Area> areaList;
38.          public ObservableCollection<Area> GridAreaList
39.          {
40.              get { return areaList; }
41.              set
42.              {
43.                 areaList = value;
44.                  RaisePropertyChanged("GridAreaList");
45.              }
46.         }
47.         private ObservableCollection<City> cityList;
49.         public ObservableCollection<City> GridCityList
50.         {
51.             get { return cityList; }
52.             set
53.             {
54.                 cityList = value;
55.                 RaisePropertyChanged("GridCityList");
56.             }
57.         }
58.    
59.         /// <summary>
60.         /// 命令要执行的方法
61.         /// </summary>
62.         void SaveExecute()
63.         {
64.             try
66.             {
67.                 GridDbContext db = new GridDbContext();
68.                 var list=db.Area.AsTracking().ToList();
69.                 Area modifyArea = list.Where(x=>x.Id==AreaVM.Id).FirstOrDefault();
70.                 if (modifyArea != null)
71.                 {
72.                     modifyArea.Name = AreaVM.Name;
73.                     modifyArea.Updated = DateTime.Now;
74.                     db.SaveChanges();
75.                 }
77.             }
78.             catch (Exception ex)
79.             {
81.                 throw ex;
82.             }
83.         }
85.         /// <summary>
86.         /// 命令是否可以执行
87.         /// </summary>
88.         /// <returns></returns>
89.         bool CanSaveExecute()
90.         {
91.             return false;
92.         }
94.         /// <summary>
95.         /// 创建新命令
96.         /// </summary>
97.         public ICommand ClickSaveAction
98.         {
99.             get
100.             {
101.                 return new Command.SaveCommand(SaveExecute, CanSaveExecute);
102.             }
103.         }
104.         //combobox
105.         /// <summary>
106.         /// 命令要执行的方法
107.         /// </summary>
108.         void ProviceSelectionChangedExecute(object sender)
109.         {
110.             try
112.             {
113.                 if (sender is ComboBox)
114.                 {
115.                     ComboBox drp=sender as ComboBox;
116.                     ProvinceCode=drp.SelectedValue.ToString();
117.                     GridDbContext db = new GridDbContext();
118.                     var list = db.City.AsTracking().ToList();
120.                     List<City> citys = list.Where(x => x.ProvinceCode == ProvinceCode).ToList();
121.                     var cityCodes = from city in citys
122.                                     select city.Code;
123.                     List<Area> areas = db.Area.AsTracking().ToList().Where(<br>x => cityCodes.Contains(x.CityCode)).ToList();
124.                     areaList.Clear();
125.                     if (areas!=null)
126.                     {
127.                         areas.ForEach((t) =>
129.                         { areaList.Add(t); }
130.                         );
131.                     }
133.                     cityList.Clear();
134.                     if (citys != null)
135.                     {
136.                         citys.ForEach((t) =>
138.                         { cityList.Add(t); }
139.                         );
140.                     }
141.                 }
142.             }
143.             catch (Exception ex)
144.             {
146.                 throw ex;
147.             }
148.         }
150.         /// <summary>
151.         /// 命令是否可以执行
152.         /// </summary>
153.         /// <returns></returns>
154.         bool CanSelectionChangedExecute()
155.         {
156.             return true;
157.         }
159.         /// <summary>
160.         /// 创建新命令
161.         /// </summary>
162.         public ICommand ProviceChangedAction
163.         {
165.             get
166.             {
168.                 return new Command.ProvinceChangedCommand<object>(ProviceSelectionChangedExecute,
169. CanSelectionChangedExecute);
170.             }
171.         }
172.     }

复制代码

12.在Visual Studio 2022中按F5键，启动WPF应用程序。然后使用鼠标点击省份下拉框，能够看到，界面中DataGrid中的数据，随着下拉框的变化而随之变化。如下图。

 

来源:https://www.cnblogs.com/chillsrc/archive/2023/06/18/17488927.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！