浅谈WPF之DataGrid动态生成列

小拼

在日常开发中，DataGrid作为二维表格，非常适合数据的展示和统计。通常情况下，一般都有固定的格式和确定的数据列展示，但是在某些特殊情况下，也可能会需要用到动态生成列。本文以一些简单的小例子，简述在WPF开发中，如何动态生成DataGrid的行和列，仅供学习分享使用，如有不足之处，还请指正。

 
涉及知识点

 
在本示例中，用到的知识点如下所示：

• CommunityToolkit.Mvvm，微软提供的一个基于.Net的MVVM框架库，通过此库，可以方便是实现数据绑定和命令绑定，达到前后端分离的目的。
  
• ObservableCollection ，相比较于List，当列表中的数据条数发生变化时，会自动进行通知，实现数据的实时更新。
  
• DataTable，表示内存的一个数据表格，可以动态创建列，并自动绑定到DataGrid中。
  
• ExpandoObject 表示一个动态对象，其内容可以动态添加和删除。
  

 
普通绑定

 
将ViewModel中的列表对象，绑定到View页面中的DataGrid，实现步骤如下：
 
1. 创建模型

 
创建绑定到DataGrid中的对象模型，如下所示：

1. public class Student
2. {
3.         /// <summary>
4.         /// 唯一标识
5.         /// </summary>
6.         public int Id { get; set; }
8.         /// <summary>
9.         /// 姓名
10.         /// </summary>
11.         public string Name { get; set; }
13.         /// <summary>
14.         /// 年龄
15.         /// </summary>
16.         public int Age { get; set; }
18.         /// <summary>
19.         /// 性别
20.         /// </summary>
21.         public string Gender { get; set; }
23.         /// <summary>
24.         /// 地址
25.         /// </summary>
26.         public string Addr { get; set; }
27. }

复制代码

 
2. 创建数据源列表对象

 
创建要绑定到视图层的列表对象Students，并赋值，如下所示：

1. public class GeneralBindingViewModel:ObservableObject
2. {
3.         private ObservableCollection<Student> students;
5.         public ObservableCollection<Student> Students
6.         {
7.                 get { return students; }
8.                 set { SetProperty(ref students, value); }
9.         }
11.         public GeneralBindingViewModel()
12.         {
13.                 Students=new ObservableCollection<Student>();
14.         }
16.         #region Loaded命令
18.         private ICommand winLoadedCommand;
20.         public ICommand WinLoadedCommand
21.         {
22.                 get
23.                 {
24.                         if (winLoadedCommand == null)
25.                         {
26.                                 winLoadedCommand = new RelayCommand<object>(WinLoaded);
27.                         }
28.                         return winLoadedCommand;
29.                 }
30.         }
32.         private void WinLoaded(object sender)
33.         {
34.                 if (sender != null)
35.                 {
37.                 }
38.                 if (Students == null || Students.Count < 1)
39.                 {
40.                         var parentName = new string[5] { "张", "王", "李", "赵", "刘" };
41.                         var province = new string[5] { "河南", "江苏", "河北", "湖北", "福建" };
42.                         for (int i = 0; i < 20; i++)
43.                         {
44.                                 var student = new Student()
45.                                 {
46.                                         Id = i,
47.                                         Name = parentName[(i % 4)] + i.ToString().PadLeft(2, 'A'),
48.                                         Age = 20 + (i % 5),
49.                                         Gender = i % 2 == 0 ? "男" : "女",
50.                                         Addr = province[(i % 4)]
51.                                 };
52.                                 this.Students.Add(student);
53.                         }
54.                 }
55.         }
57.         #endregion
58. }

复制代码

 
3. 视图绑定

 
在UI视图中，为DataGrid的ItemsSource属性绑定数据源，如下所示：

1. <Window x:
2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
4.         xmlns:i="http://schemas.microsoft.com/xaml/behaviors"
5.         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
6.         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
7.         xmlns:local="clr-namespace:DemoDynamicBinding"
8.         mc:Ignorable="d"
9.         Title="基础绑定" Height="450" Width="800">
10.     <i:Interaction.Triggers>
11.         <i:EventTrigger EventName="Loaded">
12.             <i:InvokeCommandAction Command="{Binding WinLoadedCommand}" CommandParameter="{Binding RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=Window}}"/>
13.         </i:EventTrigger>
14.     </i:Interaction.Triggers>
15.     <Grid>
16.         <DataGrid ItemsSource="{Binding Students}" CanUserAddRows="False" CanUserDeleteRows="False" ColumnWidth="*" ColumnHeaderHeight="30" RowHeight="25" AlternationCount="2" AlternatingRowBackground="AliceBlue" RowBackground="#ffffee">
17.             
18.         </DataGrid>
19.     </Grid>
20. </Window>

复制代码

 
4. 关联视图层和ViewModel层

 
在视图文件对应的cs文件中，创建ViewModel对象，如下所示：

1. public partial class GeneralBinding : Window
2. {
3.         private GeneralBindingViewModel viewModel;
5.         public GeneralBinding()
6.         {
7.                 InitializeComponent();
8.                 if(viewModel == null)
9.                 {
10.                         viewModel = new GeneralBindingViewModel();
11.                         this.DataContext = viewModel;
12.                 }
13.         }
14. }

复制代码

 
动态生成列

 
在WPF开发中，动态生成DataGrid列，共有两种方式：
 
1. DataTable作为数据源

 
通过DataTable作为数据源，可以不用创建模型，也不需要使用ObservableCollection对象，直接使用DataTable作为数据承载对象，DataGrid会根据DataTable的Columns列表自动生成列。如下所示：

1. public class DataTableBindingViewModel:ObservableObject
2. {
3.         private DataTable students;
5.         public DataTable Students
6.         {
7.                 get { return students; }
8.                 set { SetProperty(ref students , value); }
9.         }
11.         public DataTableBindingViewModel()
12.         {
13.                 Students = new DataTable();
14.         }
16.         #region Loaded命令
18.         private ICommand winLoadedCommand;
20.         public ICommand WinLoadedCommand
21.         {
22.                 get
23.                 {
24.                         if (winLoadedCommand == null)
25.                         {
26.                                 winLoadedCommand = new RelayCommand<object>(WinLoaded);
27.                         }
28.                         return winLoadedCommand;
29.                 }
30.         }
32.         private void WinLoaded(object sender)
33.         {
34.                 if (sender != null)
35.                 {
37.                 }
38.                 if (Students == null || Students.Rows.Count < 1)
39.                 {
40.                         var students = new DataTable();
41.                         students.Columns.Add("Id",typeof(int));
42.                         students.Columns.Add("Name", typeof(string));
43.                         students.Columns.Add("Age", typeof(int));
44.                         students.Columns.Add("Gender", typeof(string));
45.                         students.Columns.Add("Addr", typeof(string));
46.                         var parentName = new string[5] { "张", "王", "李", "赵", "刘" };
47.                         var province = new string[5] { "河南", "江苏", "河北", "湖北", "福建" };
48.                        
49.                         for (int i = 0; i < 20; i++)
50.                         {
51.                                 var dr = students.NewRow();
52.                                 dr["Id"] = i;
53.                                 dr["Name"] = parentName[(i % 5)] + i.ToString().PadLeft(2, 'A');
54.                                 dr["Age"] = 20 + (i % 5);
55.                                 dr["Gender"] = i % 2 == 0 ? "男" : "女";
56.                                 dr["Addr"] = province[(i % 5)];
57.                           
58.                                 students.Rows.Add(dr);
59.                         }
60.                         this.Students= students;
61.                 }
62.         }
64.         #endregion
66. }

复制代码

 
2. ExpandoObject作为模型

 
ExpandoObject是dynamic类型，可以在运行时动态的添加和删除内容。而且ExpandoObject对象支持Key=Value形式，并可以对Key进行绑定。如下所示：

1. public class DynamicBindingViewModel : ObservableObject
2. {
3.         private ObservableCollection<ExpandoObject> students;
5.         public ObservableCollection<ExpandoObject> Students
6.         {
7.                 get { return students; }
8.                 set { SetProperty(ref students , value); }
9.         }
11.         private DataGrid dataGrid;
14.         public DynamicBindingViewModel()
15.         {
16.                 this.Students = new ObservableCollection<ExpandoObject>();
17.         }
19.         #region Loaded命令
21.         private ICommand winLoadedCommand;
23.         public ICommand WinLoadedCommand
24.         {
25.                 get
26.                 {
27.                         if (winLoadedCommand == null)
28.                         {
29.                                 winLoadedCommand = new RelayCommand<object>(WinLoaded);
30.                         }
31.                         return winLoadedCommand;
32.                 }
33.         }
35.         private void WinLoaded(object sender)
36.         {
37.                 if (sender != null)
38.                 {
39.                         var control = sender as DynamicBinding;
40.                         if (control != null)
41.                         {
42.                                 this.dataGrid = control.dgTest;
43.                         }
44.                 }
45.                 if (Students == null || Students.Count < 1)
46.                 {
47.                         var parentName = new string[5] { "张", "王", "李", "赵", "刘" };
48.                         var province = new string[5] { "河南", "江苏", "河北", "湖北", "福建" };
49.                         for (int i = 0; i < 20; i++)
50.                         {
51.                                 dynamic item = new ExpandoObject();
52.                                 item.Id=i.ToString();
53.                                 item.Name = parentName[(i % 5)] + i.ToString().PadLeft(2, 'A');
54.                                 item.Age = 20 + (i % 5);
55.                                 item.Gender = i % 2 == 0 ? "男" : "女";
56.                                 item.Addr = province[(i % 5)];
57.                                 this.Students.Add(item);
58.                         }
59.                         //添加列
60.                         this.dataGrid.Columns.Add(new DataGridTextColumn() { Header = "学号", Binding = new Binding("Id") });
61.                         this.dataGrid.Columns.Add(new DataGridTextColumn() { Header = "姓名", Binding = new Binding("Name") });
62.                         this.dataGrid.Columns.Add(new DataGridTextColumn() { Header = "年龄", Binding = new Binding("Age") });
63.                         this.dataGrid.Columns.Add(new DataGridTextColumn() { Header = "性别", Binding = new Binding("Gender") });
64.                         this.dataGrid.Columns.Add(new DataGridTextColumn() { Header = "地址", Binding = new Binding("Addr") });
65.                 }
66.         }
68.         #endregion
69. }

复制代码

 
示例效果

 
以上三种方式，实现的效果都是一致的，只是分别应用到不同的场景中，如下所示：

 
源码下载

 
关于源码下载，可关注公众号，回复关键字：WDDGRID 即可，如下所示：

以上就是【浅谈WPF之DataGrid动态生成列】的全部内容，关于更多详细内容，可参考官方文档。希望能够一起学习，共同进步。
学习编程，从关注【老码识途】开始，为大家分享更多文章！！！

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