Chúng ta nhìn thế giới sai và nói rằng nó đã lừa dối chúng ta. --Bộ sưu tập chim.

Lời nói đầu

Để so sánh, lệnh là một khái niệm mới đối với tôi, vì không có khái niệm nào như lệnh trong Winform. Từ góc độ nghĩa đen, "lệnh" có thể đề cập đến một hướng dẫn hoặc yêu cầu rõ ràng được sử dụng để truyền đạt một hoạt động hoặc hành vi cụ thể tới một thực thể. Nó có thể là một từ bằng lời nói thể hiện yêu cầu hoặc hướng dẫn đối với một đối tượng hoặc chủ đề. Các lệnh thường có mục tiêu và nội dung thực hiện rõ ràng. Chúng cho người nhận biết phải làm gì và hạn chế hành vi ở một mức độ nào đó.

Trong phát triển phần mềm, "lệnh" là một mẫu thiết kế mô tả cách đóng gói các hoạt động dưới dạng đối tượng để sử dụng và tái sử dụng trong các ngữ cảnh khác nhau. Mẫu lệnh này tách rời người gửi và người nhận bằng cách đóng gói các yêu cầu và hoạt động vào một đối tượng lệnh, từ đó đạt được thiết kế linh hoạt và có thể mở rộng hơn. Trong chế độ này, đối tượng lệnh đóng vai trò trung gian giữa người gửi và người nhận và người nhận hoàn thành một thao tác cụ thể bằng cách thực thi đối tượng lệnh.

Khi nói về mệnh lệnh, chúng ta thường so sánh chúng với các sự kiện. Tất cả chúng ta đều biết rằng đã có các sự kiện được định tuyến trong WPF, chẳng hạn như phản ứng của một nút sau khi được nhấp vào (sự kiện trực tiếp). Chúng ta thường tạo một sự kiện mới thông qua Nhấp chuột vào Nút và sau đó viết một số mã nghiệp vụ trong sự kiện này:

                        
                          private void Button_Click(object sender, RoutedEventArgs e) { MessageBox.Show("Bạn nhấp vào tôi."); }

                        
                      

Khi chúng ta chạy chương trình và nhấp vào nút, sự kiện Button_Click sẽ xuất hiện hộp thoại thông báo phản hồi lại hành động nhấp chuột. Không có vấn đề gì phải không? Tất cả chúng ta đều biết rằng trong các khung GUI ban đầu, không có sự tách biệt thực sự giữa giao diện và cách ứng dụng hoạt động, và điều tương tự cũng được áp dụng ở đây. Viết mã nghiệp vụ trực tiếp trong trình xử lý sự kiện sẽ khiến giao diện và logic nghiệp vụ được kết hợp chặt chẽ với nhau. , khiến cả hai khó có thể tách rời và thay đổi độc lập. Trong quá trình phát triển thực tế, chúng tôi sẽ cung cấp cho nút một chức năng cụ thể. Khi chức năng của nút thay đổi, chúng tôi cần sửa đổi những thứ liên quan đến chức năng này trong giao diện UI và cũng cần điều chỉnh mã nghiệp vụ dẫn đến giao diện. các phần tử (Giao diện) và logic nghiệp vụ (hành vi) được trộn lẫn với nhau, do đó mã XAML của nút đảm nhận cả định nghĩa về diện mạo và việc triển khai logic nghiệp vụ. Ngoài ra, giả sử chúng ta có nhiều nút giống nhau thì chúng ta đều cần cung cấp chức năng giống nhau sau khi người dùng nhấp vào nút. Thông qua phương pháp trên, khi chức năng này thay đổi, chúng ta cần điều chỉnh từng nút liên quan và các sự kiện tương ứng. Để giải quyết vấn đề này, WPF cung cấp một cơ chế lệnh (Command) có thể tách biệt hành vi của nút với hình thức bên ngoài của nó.

Các lệnh trong WPF là một cơ chế xử lý các tương tác giao diện người dùng. Chúng cung cấp cách tách riêng các thành phần giao diện (UI) và logic nền để các hoạt động tương tác có thể được thực hiện một cách thống nhất, được xử lý theo cách có thể sử dụng lại. Khái niệm và cách triển khai các lệnh WPF dựa trên mẫu kiến ​​trúc MVVM (Model-View-ViewModel), cho phép quản lý và xử lý các hoạt động tương tác của các thành phần giao diện thông qua các đối tượng lệnh mà không cần phải viết trực tiếp các trình xử lý sự kiện vào mã giao diện.

Bằng cách sử dụng các lệnh, chúng ta có thể tổ chức và quản lý các hành vi tương tác giao diện tốt hơn, làm cho cấu trúc mã rõ ràng, dễ bảo trì và mở rộng. Đồng thời, lệnh còn cung cấp thêm một số chức năng như truyền tham số, kiểm soát tính khả dụng của lệnh, v.v., cho phép chúng ta xử lý các thao tác của người dùng linh hoạt hơn.

Sự kiện và lệnh:

Các sự kiện được liên kết với hành động của người dùng, trong khi lệnh là những hành động muốn tách biệt khỏi giao diện, chẳng hạn như lệnh sao chép và dán thông thường. Khi chúng ta nhấp vào nút có chức năng sao chép, nó tương đương với việc kích hoạt một lệnh sao chép. - tương tác giao diện trở nên đơn giản hơn, khả năng sử dụng lại mã được cải thiện và giao diện người dùng có thể được điều khiển linh hoạt hơn mà không phá hủy logic nền.

mô hình lệnh

Mô hình lệnh WPF chủ yếu chứa các thành phần cơ bản sau:

Lệnh: đề cập đến một lớp thực hiện giao diện ICommand, chẳng hạn như lớp RoutedCommand và lớp con RoutedUICommand của nó, thường không chứa logic cụ thể.

Nguồn lệnh: Người gửi lệnh, đề cập đến lớp thực hiện giao diện ICommandSource. Các thành phần giao diện như Button và MenuItem đều triển khai giao diện này và việc nhấp vào chúng sẽ thực thi các lệnh bị ràng buộc.

Mục tiêu lệnh: Người nhận lệnh, đề cập đến lớp thực hiện giao diện IInputElement.

Ràng buộc lệnh: Liên kết một số logic ngoại vi với các lệnh.

Hãy dùng hình ảnh của cô Lưu để xem xét mối quan hệ của họ.

Lệnh ICommand

Giao diện ICommand chứa hai phương thức cho một sự kiện:

                        
                          giao diện công cộng ICommand { // // Tóm tắt: // Xảy ra khi có một thay đổi xảy ra ảnh hưởng đến việc lệnh có được thực thi hay không. event EventHandler CanExecuteChanged; // Tóm tắt: // Xác định phương thức được sử dụng để xác định xem lệnh này có thể được thực thi ở trạng thái hiện tại hay không. // // Tham số: // tham số: // Dữ liệu được sử dụng bởi lệnh này. Đối tượng này có thể được đặt thành null nếu lệnh này không yêu cầu truyền dữ liệu. // // Trả về kết quả: // true nếu lệnh này có thể được thực thi; nếu không thì trả về false. bool CanExecute(object tham số); // // Tóm tắt: // Xác định phương thức được gọi khi lệnh này được gọi. // // Tham số: // tham số: // Dữ liệu được sử dụng bởi lệnh này. Đối tượng này có thể được đặt thành null nếu lệnh này không yêu cầu truyền dữ liệu. void Thực thi(tham số đối tượng); }

                        
                      

Nhìn nó theo cách khác:

• Thực hiện - thực hiện một hành động.

• CanExecute - liệu hành động có thể được thực thi hay không.

• CanExecuteChanged - Một sự kiện được phản hồi khi xảy ra thay đổi trạng thái lệnh.

Bằng cách triển khai giao diện ICommand, chúng ta có thể tạo các đối tượng lệnh tùy chỉnh và liên kết chúng với các thành phần giao diện. Bằng cách này, các phần tử giao diện có thể được liên kết với các lệnh và thực hiện các thao tác cụ thể bằng cách gọi phương thức Thực thi của lệnh mà không cần viết trực tiếp các trình xử lý sự kiện.

xác định lệnh

Tiếp theo, chúng ta thử sử dụng các lệnh để thực hiện sự kiện click trên và dần dần hiểu được nội dung trong mô hình. Chúng tôi tạo một lớp MainViewModel mới để cung cấp các phương thức chức năng mà chúng tôi cần:

                        
                          sử dụng System.Windows; không gian tên WPFDemo { lớp công khai MainViewModel { void công khai ShowInfo() { MessageBox.Show("Bạn nhấp vào tôi."); } } }

                        
                      

ShowInfo() lúc này tách biệt với giao diện UI phải không? Sau khi có phương thức, chúng ta có thể nói rằng lệnh ShowInfo trong MainViewModel là chưa đủ theo mô hình. Tiếp tục viết một lớp triển khai giao diện ICommand nhưng không có logic cụ thể, chẳng hạn như CustomCommand

                        
                          sử dụng System; sử dụng System.Windows.Input; không gian tên WPFDemo { lớp công khai CustomCommand : ICommand { Hành động chỉ đọc riêng tư _execute; public CustomCommand(Action exec) { _execute = exec } sự kiện công khai EventHandler CanExecuteChanged; / Triển khai logic thực thi của lệnh ở đây return true; // Trả về true theo mặc định, cho biết lệnh có thể thực thi được} public void Thực thi (tham số đối tượng) { // Triển khai logic thực thi của lệnh here_execute?.Invoke() } } }

                        
                      

Sau đó, bạn cần thêm thuộc tính công khai trong lớp MainViewModel để hiển thị phiên bản CustomCommand dưới dạng ShowInfoCommand để liên kết trong XAML.

                        
                          sử dụng System.Windows; không gian tên WPFDemo { lớp công khai MainViewModel { lệnh CustomCommand công khai ShowInfoCommand { lấy; đặt; } lệnh MainViewModel() { lệnh ShowInfoCommand = lệnh CustomCommand mới (ShowInfo); } lệnh void ShowInfo() { MessageBox.Show("Bạn nhấp vào tôi."); } } }

                        
                      

Cuối cùng, liên kết phiên bản CustomCommand với thành phần giao diện:

Việc đặt bối cảnh dữ liệu cũng có thể được thực hiện bằng mã phía sau.

Quay lại mô hình lệnh, sắp xếp các tương ứng sau:

1. Lệnh tùy chỉnh Bản thân lớp này là một đối tượng lệnh ( Lệnh ICommand ), thực hiện giao diện lệnh, bao gồm Thực hiện Và Có thể thực hiện phương pháp. Đối tượng lệnh này là "lệnh cụ thể" trong chế độ lệnh.
2. MainViewModel Lớp này đóng vai trò là người thực thi lệnh (hoặc đích lệnh), chứa Hiển thịThông tin phương pháp. Trong mẫu lệnh, người thực thi chịu trách nhiệm về các hành động thực tế cần thiết để thực thi lệnh. Trong ví dụ của chúng tôi, Hiển thịThông tin Các phương thức được thực thi logic nghiệp vụ cụ thể.
3. hiện hữu XAML , chúng tôi sử dụng Liên kết lệnh Thay đổi nút Nhấp chuột sự kiện và Hiển thị lệnh thông tin Liên quan. Sự liên kết này thông qua Cửa sổ hoặc Kiểm soát người dùng của Liên kết lệnh Thêm một cái mới vào bộ sưu tập Liên kết lệnh đối tượng cần hoàn thành. cái này Liên kết lệnh được chỉ định Hiển thị lệnh thông tin như một mệnh lệnh và MainViewModel Với tư cách là người thi hành mệnh lệnh.

Lưu ý: Thuộc tính Lệnh chỉ được sử dụng làm ràng buộc cho hành vi Nhấp chuột, các hành vi khác, chẳng hạn như di chuyển chuột vào và ra. . . Đối với các hành vi khác, bạn cần sử dụng phương thức MVVM khác để liên kết.

Cuối cùng, sắp xếp cấu trúc chương trình, bạn có thể thấy rằng chúng tôi viết mã nghiệp vụ và logic trong MainViewModel.cs và MainWindow.xaml tương ứng.

Thông báo thay đổi

Trong WPF, thông báo về các thay đổi thuộc tính được thực hiện bằng cách triển khai giao diện INotifyPropertyChanged. Giao diện này xác định một sự kiện PropertyChanged Khi giá trị của thuộc tính thay đổi, sự kiện này có thể được kích hoạt để thông báo cho giao diện cập nhật.

Trước khi trình diễn, hãy xem liệu ví dụ chúng tôi sử dụng ở trên có thể được cập nhật tự động giống như liên kết mà chúng tôi đã học trước đó hay không. Theo logic phân tách nghiệp vụ, chúng tôi thêm trường Tên vào MainViewModel.cs và liên kết nó trên trang.

MainViewModel.cs:

                        
                          sử dụng System.Windows; không gian tên WPFDemo { public class MainViewModel { public CustomCommand ShowInfoCommand { set; } public string Name { get; CustomCommand (ShowInfo); } public void ShowInfo() { Name = "hói đầu mạnh mẽ"; Tôi."); } } }

                        
                      

Cửa sổ chính.xaml:

Ngữ cảnh dữ liệu trong xaml trước đây không tốt lắm và cần được xác định một lần trong mỗi điều khiển.

Trong đoạn mã trên, chúng tôi liên kết Tên với văn bản của TextBox và thay đổi giá trị của Tên khi nhấp vào nút. Nếu nó có thể thông báo thay đổi và cập nhật tự động thì văn bản cũng sẽ thay đổi khi Tên thay đổi. Phải. Hãy thử nó bằng cách chạy:

Có thể thấy Text không thay đổi khi Name thay đổi, tức là Text không được thông báo thay đổi sau khi Name thay đổi. Nếu thích mày mò, bạn có thể xem Tên có thay đổi nếu Văn bản được sửa đổi hay không.

Quay lại chủ đề, như đã đề cập ở trên, thay đổi thông báo của thuộc tính được triển khai bằng cách triển khai giao diện INotifyPropertyChanged. Hãy sửa đổi một chút MainViewModel.cs tùy chỉnh để triển khai thay đổi thông báo của thuộc tính:

                        
                          sử dụng System.ComponentModel; sử dụng System.Windows; không gian tên WPFDemo { public class MainViewModel : INotifyPropertyChanged { public CustomCommand ShowInfoCommand { get; set; } public event PropertyChangedEventHandler PropertyChanged; private string _name; public string Name { get { return _name; } set { _name = value; OnPropertyChanged(nameof(Name)); } } private void OnPropertyChanged(string name) { PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name)); } public MainViewModel() { Name = "Sự kiện thay đổi"; ShowInfoCommand = new CustomCommand(ShowInfo); } public void ShowInfo() { Name = "Sự kiện thay đổi"; MessageBox.Show("Bạn nhấp vào tôi."); } } }

                        
                      

nameof(Name) là một cú pháp được giới thiệu trong C# 6.0. Nó có thể lấy tên của các thuộc tính, phương thức, trường, kiểu và các thành viên khác dưới dạng chuỗi tại thời điểm biên dịch.

Trong WPF, nameof(Name) được sử dụng để chỉ định tên của thuộc tính trong thông báo thay đổi thuộc tính. Mục đích của nó là tránh việc mã hóa cứng tên thuộc tính, từ đó giảm thiểu lỗi do đổi tên thuộc tính trong quá trình tái cấu trúc.

Sau khi sửa đổi, lớp MainViewModel triển khai giao diện INotifyPropertyChanged và thực hiện thông báo thay đổi thuộc tính trong setter của thuộc tính Name. Khi giá trị của thuộc tính Name thay đổi, sự kiện PropertyChanged sẽ được kích hoạt để thông báo cho giao diện cập nhật.

Lối chơi nâng cao

Trong cách triển khai thông báo thay đổi, logic của thay đổi thông báo có thể được xác định trong lớp cơ sở, chẳng hạn như lớp ViewModelBase. Lớp cơ sở này có thể chứa cách triển khai thông báo thay đổi thuộc tính chung để các lớp mô hình dạng xem cụ thể khác có thể kế thừa từ lớp cơ sở này và sử dụng lại các chức năng thông báo thay đổi này.

Dưới đây là một ví dụ đơn giản cho thấy cách triển khai thông báo thay đổi trong lớp ViewModelBase:

                        
                          sử dụng System.ComponentModel; sử dụng System.Runtime.CompilerServices; không gian tên WPFDemo { lớp công khai ViewModelBase: INotifyPropertyChanged { sự kiện công khai PropertyChangedEventHandler PropertyChanged; được bảo vệ virtual void OnPropertyChanged([CallerMemberName] chuỗi propertyName = null) { PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); } } }

                        
                      

Trong đoạn mã trên, lớp ViewModelBase triển khai giao diện INotifyPropertyChanged và cung cấp phương thức OnPropertyChanged để kích hoạt sự kiện thông báo thay đổi thuộc tính và chuyển tên thuộc tính làm tham số.

Theo mặc định, thuộc tính CallerMemberName được sử dụng để tự động lấy tên của thành viên mà phương thức được gọi, được chuyển làm tên thuộc tính.

Bạn có thể đơn giản hóa việc triển khai thông báo thay đổi thuộc tính trong lớp mô hình khung nhìn của mình bằng cách kế thừa lớp ViewModelBase và sử dụng phương thức OnPropertyChanged để đặt thuộc tính:

MainViewModel.cs:

                        
                          sử dụng System.Windows; không gian tên WPFDemo { public class MainViewModel : ViewModelBase { public CustomCommand ShowInfoCommand { get; } chuỗi riêng tư Tên chuỗi công khai { get { return _name } set { _name = value; chuỗi _description; chuỗi công khai Mô tả { get { return _description } set { _description = value; OnPropertyChanged(); } } public MainViewModel() { Name = "Súng bắn tỉa số 1 của Gou Xiong Ridge"; Mô tả = "Bald Qiang"; Bald Qiang" ; Description = "Người chơi đột phá số một trong Gou Xiong Ling, MacArthur đã nói như vậy."; MessageBox.Show("Bạn nhấp vào tôi."); } } }

                        
                      

Trong ví dụ này, lớp MainViewModel kế thừa lớp ViewModelBase và sử dụng phương thức OnPropertyChanged để đặt thuộc tính Name. Khi giá trị của thuộc tính Tên thay đổi, phương thức SetProperty sẽ tự động xử lý logic của thông báo thay đổi thuộc tính, loại bỏ nhu cầu kích hoạt sự kiện theo cách thủ công hoặc viết mã trùng lặp.

Bằng cách xác định việc triển khai các thay đổi thông báo trong lớp cơ sở, bạn có thể đạt được mã ngắn gọn hơn, dễ bảo trì và có thể sử dụng lại hơn, đồng thời tránh trùng lặp logic của các thay đổi thông báo trong từng lớp mô hình khung nhìn cụ thể.

Chở hàng riêng - thông số lệnh

Đôi khi chúng ta cần truyền tham số khi thực thi lệnh. Trong WPF, bạn có thể sử dụng thuộc tính CommandParameter để truyền tham số cho lệnh.

CommandParameter là thuộc tính bổ sung cho phép bất kỳ đối tượng nào được chỉ định làm tham số lệnh. Khi lệnh được thực thi, phương thức Thực thi của lệnh sẽ nhận tham số này và có thể sử dụng nó trong logic xử lý lệnh.

Dưới đây là ví dụ cho thấy cách chỉ định CommandParameter cho lệnh trong XAML:

。

Trong ví dụ này, chúng tôi liên kết thuộc tính Command của Button với lệnh MyCommand. Đồng thời, chúng tôi chỉ định tham số chuỗi "Xin chào, Thế giới!" thông qua thuộc tính CommandParameter. Tham số này được chuyển tới phương thức Thực thi của lệnh MyCommand khi nhấp vào nút.

Trong logic thực thi lệnh, giá trị được truyền có thể thu được thông qua các tham số lệnh. Đây là một ví dụ về lớp lệnh đơn giản:

CustomCommand.cs:

                        
                          sử dụng System; sử dụng System.Windows.Input; không gian tên WPFDemo { public class CustomCommand : ICommand { riêng tư chỉ đọc Action
                      

Lớp CustomCommand chấp nhận một tham số kiểu Action