MVVM में शामिल है

उद्देश्य : जब उपयोगकर्ता किसी तत्व पर क्लिक करता है, तो दृश्य मॉडल के संबंधित फ़ंक्शन को कॉल करें।

अब आज्ञाओं का उपयोग करने का सबसे सरल उदाहरण देखें। सबसे पहले, हम अपने ऑब्जेक्ट मॉडल में कमांड ऑब्जेक्ट जोड़ते हैं - एक संबद्ध फ़ंक्शन जिसे कमांड कहा जाता है:

 public class MainViewModel : ViewModel { public MainViewModel() { //   -  DoSimpleCommand. simpleCommand = new Command(DoSimpleCommand); } /// <summary> /// The SimpleCommand function. /// </summary> private void DoSimpleCommand() { //   Messages.Add(" 'DoSimpleCommand'."); } /// <summary> ///    /// </summary> private Command simpleCommand; /// <summary> ///    /// </summary> public Command SimpleCommand { get { return simpleCommand; } } } 

अब बटन नियंत्रण के "कमांड" संपत्ति में एक कमांड जोड़ें।

 <Button Content="Simple Command" Command="{Binding SimpleCommand}" /> 

वह सब है। सबसे सरल उदाहरण है। हमने इंटरफ़ेस तत्व की कमांड प्रॉपर्टी पर कमांड ऑब्जेक्ट संलग्न किया है। जब कोई तत्व सक्रिय होता है, अर्थात जब एक बटन दबाया जाता है, तो एक कमांड को बुलाया जाता है (इसी DoSimpleCommand फ़ंक्शन को कहा जाता है)।

उद्देश्य : सक्रियण या इंटरफ़ेस तत्व पर क्लिक करने के दौरान दृश्य मॉडल फ़ंक्शन को कॉल करें।

हालांकि, यह एक बहुत ही सरल कार्य है, जिसे मैं स्पष्ट रूप से नहीं लिखना पसंद करता हूं और इसके बजाय एक लंबोदर अभिव्यक्ति का उपयोग करता हूं।

इस मैनुअल के सभी उदाहरणों में, आप या तो स्पष्ट रूप से एक फ़ंक्शन बना सकते हैं, उदाहरण के लिए, उदाहरण 1 में, या मेमने का उपयोग करें, जो कोड को थोड़ा कम करेगा और इसे और अधिक सुरुचिपूर्ण बना देगा। चुनाव आपका है।

 public MainViewModel() { //      .      . lambdaCommand = new Command( () => { Messages.Add("    .      . "); }); } /// <summary> /// The command object. /// </summary> private Command lambdaCommand; /// <summary> /// Gets the command. /// </summary> public Command LambdaCommand { get { return lambdaCommand; } } 

फिर से, हम कमांड को हमारे बटन की कमांड प्रॉपर्टी से बाँधने की प्रक्रिया को दोहराएंगे:

 <Button Content="Lambda Command" Command="{Binding LambdaCommand}" /> 

उद्देश्य : एक टीम बनाएं जो डेटा बाइंडिंग के दौरान पास किए गए पैरामीटर का उपयोग करता है।

इस उदाहरण में, हम कमांड ऑब्जेक्ट का उपयोग करते हैं (यह एसिंक्रोनसकॉसमंड ऑब्जेक्ट का उपयोग करना भी संभव है, जिसे हम थोड़ी देर बाद देखेंगे)। पारित पैरामीटर को तथाकथित फ़ंक्शन में उपयोग किया जा सकता है।

 public class MainViewModel : ViewModel { public MainViewModel() { //    parameterizedCommand = new Command(DoParameterisedCommand); } /// <summary> ///   /// </summary> private void DoParameterisedCommand(object parameter) { Messages.Add("   –  : '" + parameter.ToString() + "'."); } /// <summary> /// The command object. /// </summary> private Command parameterizedCommand; /// <summary> /// Gets the command. /// </summary> public Command ParameterisedCommand { get { return parameterizedCommand; } } } 

बटन या किसी अन्य तत्व के लिए कमांड के बंधन को दोहराएं। इसके अलावा, पैरामीटर जोड़ना न भूलें:

 <Button Content="Parameterized Command" Command="{Binding ParameterizedCommand}" CommandParameter={Binding SomeObject} /> 

जहां भी कमांड का उपयोग किया जाता है, उनके लिए मापदंडों को पारित करना संभव है। कमांड बनाते समय, आप एक्शन (बिना पैरामीटर के कमांड कमांड) या एक्शन <ऑब्जेक्ट> (टाइप कमांड के पैरामीटर के साथ कमांड फ़ंक्शन) का उपयोग कर सकते हैं। लैम्ब्डा के उपयोग की संभावना भी है:

 //       parameterizedCommand = new Command( (parameter) => { Messages.Add("   –  : '" + parameter.ToString() + "'."); }); 

लक्ष्य : कोड या XAML से कमांड को सक्षम / अक्षम करने की क्षमता जोड़ें

प्रत्येक कमांड में CanExecute प्रॉपर्टी होती है, जो कि सही होने पर, कमांड को शामिल करती है, और जब गलत पर सेट होती है, तो कमांड को निष्क्रिय कर देती है, साथ ही संबंधित नियंत्रण को भी। निम्नलिखित उदाहरण में, जब कमांड को अक्षम किया जाता है, तो उपयोगकर्ता इंटरफ़ेस से बटन भी गायब हो जाता है:

 public class MainViewModel : ViewModel { public MainViewModel() { //  /  enableDisableCommand = new Command( () => { Messages.Add("/ ."); }, false); } private void DisableCommand() { //   EnableDisableCommand.CanExecute = false; } private void EnableCommand() { //   EnableDisableCommand.CanExecute = true; } /// <summary> /// The command object. /// </summary> private Command enableDisableCommand; /// <summary> /// Gets the command. /// </summary> public Command EnableDisableCommand { get { return enableDisableCommand; } } } 

हम बटन (या अन्य तत्व) के लिए एक बंधन बनाते हैं:

 <Button Content="Enable/Disable Command" Command="{Binding EnableDisableCommand}" /> 

यह CanExecute कमांड प्रॉपर्टी को बांधने के लिए भी संभव है।
इस उदाहरण में, कोड में कमांड की स्थिति को नियंत्रित करने के लिए, CanExecute प्रॉपर्टी को संबंधित मान असाइन करें। और इंटरफ़ेस (XAML) के माध्यम से नियंत्रण के लिए हम एक अतिरिक्त चेकबॉक्स तत्व का उपयोग करते हैं:

 <CheckBox IsChecked="{Binding EnableDisableCommand.CanExecute, Mode=TwoWay}" Content="Enabled" /> 

भले ही हमने कहाँ और कैसे कमांड ऑब्जेक्ट बनाया है, हमारे पास हमेशा बूलियन मान को पारित करने का अवसर होता है जो कि कैनेक्स्यूट संपत्ति को दूसरे पैरामीटर के रूप में नियंत्रित करता है। डिफ़ॉल्ट रूप से - गलत पर सेट है। उदाहरण में, हम सक्षम करने के लिए सही हैं।

उद्देश्य : पता करें कि कमांड कब निष्पादित किया गया था, या इसे कब निष्पादित किया गया था।

प्रत्येक कमांड में दो घटनाएँ होती हैं: निष्पादित - कमांड के पूरा होने पर कहा जाता है, और निष्पादन के समय - निष्पादन। निष्पादन घटना भी आपको एक आदेश को रद्द करने की अनुमति देती है।

महत्वपूर्ण : कई परिस्थितियां हैं जब उपरोक्त घटनाएं बहुत उपयोगी हो जाती हैं। उदाहरण के लिए, आप एक पॉप-अप विंडो दिखाना चाहते हैं जो पूछती है कि क्या आप कमांड निष्पादित होने पर जारी रखना चाहते हैं। और ऐसे कोड को कहां रखा जाए? कमांड कोड में? यह एक बुरा विचार है, क्योंकि आपको डेटा मॉडल में इंटरफ़ेस कोड बनाना है, जो मुख्य रूप से कोड को रोकते हैं, और दूसरे में, जो कि अधिक महत्वपूर्ण है, यह इसे परीक्षण करने की अनुमति नहीं देगा। कोड को व्यू में रखना सबसे अच्छा होगा। और घटनाओं की मदद से आप इसे कर सकते हैं।
ऐसी घटनाओं की उपयोगिता को प्रदर्शित करने का दूसरा उदाहरण वह स्थिति हो सकती है जब कमांड निष्पादित होने के बाद किसी अन्य तत्व पर ध्यान केंद्रित करना आवश्यक हो जाता है। आप इसे दृश्य मॉडल में नहीं कर सकते, क्योंकि इसमें नियंत्रण (नियंत्रण) तक पहुंच नहीं है, हालांकि, घटनाओं की सदस्यता लेकर आप इसे बिना किसी समस्या के लागू कर सकते हैं।

 public class MainViewModel : ViewModel { public MainViewModel() { //     eventsCommand = new Command( () => { Messages.Add("   ."); }); 

अब बटन को बांधें:

 <Button Content="Events Command" Command="{Binding EventsCommand}" /> 

वर्तमान में पिछले उदाहरणों में कोड से कोई अंतर नहीं हैं। दृश्य में घटनाओं की सदस्यता लें।
महत्वपूर्ण: मेरे विचार में, एक DataContext जिसका नाम viewModel है:

 /// <summary> /// Interaction logic for MainWindow.xaml /// </summary> public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); viewModel.EventsCommand.Executing += new Apex.MVVM.CancelCommandEventHandler(EventsCommand_Executing); viewModel.EventsCommand.Executed += new Apex.MVVM.CommandEventHandler(EventsCommand_Executed); } void EventsCommand_Executed(object sender, Apex.MVVM.CommandEventArgs args) { viewModel.Messages.Add("   .  View!"); } void EventsCommand_Executing(object sender, Apex.MVVM.CancelCommandEventArgs args) { if (MessageBox.Show(" ?", "Cancel?", MessageBoxButton.YesNo) == MessageBoxResult.Yes) args.Cancel = true; } } 

अंत में, हम टीम कार्यान्वयन की पूरी शक्ति को समझने के करीब पहुंच गए। किसी दृश्य में (या किसी अन्य ViewModel, या ऑब्जेक्ट में) निष्पादित और निष्पादन की घटनाओं की सदस्यता लेना संभव है, और हम यह भी जानते हैं कि यह कब होता है। निष्पादन की घटना रद्द करती हैमहिलाओं को रद्द करें वस्तु - यह "रद्द करें" नाम के साथ संपत्ति है। यदि इसे सही पर सेट किया जाता है, तो कमांड निष्पादित नहीं किया जाएगा। दोनों CommandEventArgs और CancelCommandEventArgs ऑब्जेक्ट एक और गुण - पैरामीटर का समर्थन करते हैं। यह वह पैरामीटर है जिसे कमांड (यदि कोई हो) में पारित किया जा सकता है।

उद्देश्य : यदि आदेशों को लंबे समय तक निष्पादित किया जाता है, तो इंटरफ़ेस अवरुद्ध है। उन्हें अतुल्यकालिक रूप से चलाना संभव होना चाहिए।

आप एक पृष्ठभूमि प्रक्रिया की तरह कुछ बना सकते हैं और वहां एक कमांड चला सकते हैं। हालाँकि, कई सवाल तुरंत उठते हैं:
"अगर हम स्ट्रीम में एक फ़ंक्शन में ViewModel को अपडेट करना चाहते हैं तो क्या होगा?" हम उपयोगकर्ता इंटरफ़ेस में क्रियाओं का सहारा लिए बिना ऐसा नहीं कर सकते।
- यह सुनिश्चित करने के लिए कि एक टीम ने गलती से कई थ्रेड्स को कॉल नहीं किया जब इंटरफ़ेस पर केवल एक प्रभाव होता है?
- व्यू मॉडल को लिट करने के लिए कैसे नहीं, अगर कई कमांड हैं जिन्हें अलग-अलग थ्रेड्स में निष्पादित करना होगा?
- WP और सिल्वरलाइट के साथ संगतता सुनिश्चित करने के लिए कैसे, अगर प्रत्येक सिस्टम पर धाराओं के लिए विभिन्न विकल्प हैं?

AsynchronousCommand ऑब्जेक्ट इन सभी बारीकियों को ध्यान में रखते हुए बनाया गया था और न केवल। परिचित हो जाओ:

 public class MainViewModel : ViewModel { public MainViewModel() { //    asyncCommand1 = new AsynchronousCommand( () => { for (int i = 1; i <= 10; i++) { //    . asyncCommand1.ReportProgress(() => { Messages.Add(i.ToString()); }); System.Threading.Thread.Sleep(200); } }); } /// <summary> /// The command object. /// </summary> private AsynchronousCommand asyncCommand1; /// <summary> /// Gets the command. /// </summary> public AsynchronousCommand AsyncCommand1 { get { return asyncCommand1; } } } 

XAML तत्व से बांधना:

 <Button Content="Asynchronous Command" Command="{Binding AsyncCommand1}" /> 

कमांड को कॉल करने के बाद, संबंधित फ़ंक्शन को कहा जाता है, जिसे हमने लैम्ब्डा अभिव्यक्ति की मदद से निर्दिष्ट किया है, जो बदले में थ्रेड पूल से एक अलग थ्रेड में कहा जाता है।

यदि दृश्य मॉडल ऑब्जेक्ट्स के साथ कुछ करने की आवश्यकता है (जो उपयोगकर्ता इंटरफ़ेस तत्वों से जुड़ा हो सकता है), तो हम ReportProgress फ़ंक्शन का उपयोग कर सकते हैं:

 asyncCommand1.ReportProgress(() => { Messages.Add(i.ToString()); }); 

ReportProgress गारंटी देता है कि प्रेषित कोड वांछित थ्रेड में लॉन्च किया जाएगा, जो आपको आवश्यक होने पर उपयोगकर्ता इंटरफ़ेस को काफी आसानी से बदलने की अनुमति देता है।

लक्ष्य : टीम को पूरा होने में लंबा समय लगता है। प्रगति बार दिखाएं।

AsynchronousCommand में एक संपत्ति है जिसे "IsExecuting" कहा जाता है। यदि यह सच है, तो कमांड चालू है। चूंकि एसिंक्रोनसकॉसमैंड INotifyPropertyChanged इंटरफ़ेस को लागू करता है, जिसका अर्थ है कि हमारे पास इस संपत्ति को बांधने और निष्पादन प्रक्रिया दिखाने की क्षमता है।

 public class MainViewModel : ViewModel { public MainViewModel() { //    asyncCommand2 = new AsynchronousCommand( () => { for (char c = 'A'; c <= 'Z'; c++) { //    asyncCommand2.ReportProgress(() => { Messages.Add(c.ToString()); }); System.Threading.Thread.Sleep(100); } }); } /// <summary> /// The command object. /// </summary> private AsynchronousCommand asyncCommand2; /// <summary> /// Gets the command. /// </summary> public AsynchronousCommand AsyncCommand2 { get { return asyncCommand2; } } } 

हम बटन के साथ कमांड को जोड़ते हैं। और हम IsExecuting प्रॉपर्टी को एक अन्य इंटरफ़ेस तत्व से जोड़ देंगे, उदाहरण के लिए, StackPanel, जिसमें क्रमशः TextBlock और ProgressBar शामिल होंगे:

 <Button Content="Asynchronous Command" Command="{Binding AsyncCommand2}" Visibility="{Binding AsyncCommand2.IsExecuting, Converter={StaticResource BooleanToVisibilityConverter}, ConverterParameter=Invert}" /> <StackPanel Visibility="{Binding AsyncCommand2.IsExecuting, Converter={StaticResource BooleanToVisibilityConverter}}"> <TextBlock Text="The command is running!" /> <ProgressBar Height="20" Width="120" IsIndeterminate="True" /> </StackPanel> 

इस उदाहरण में, जैसे ही कमांड निष्पादित करना शुरू करता है, बटन गायब हो जाता है, और एक शिलालेख और प्रगति बार दिखाई देता है। कृपया ध्यान दें कि हम कमांड के IsExecuting गुण के लिए बाध्य हैं।

 asyncCommand1.ReportProgress(() => { Messages.Add(i.ToString()); }); 

नोट : इनवर्टर पैरामीटर को बूलियनटॉइज़िलिटीकॉन्वर्टर को पास किया जा सकता है, क्योंकि यह मानक बूलियनटॉइसिबिलिटी का एक विस्तारित संस्करण है, जो एपेक्स.ऑनवर्टर्स में परिभाषित किया गया है। परिणाम निकालता है। कुछ बिंदुओं पर एक बहुत उपयोगी छोटी चीज।

उद्देश्य : उपयोगकर्ता को अतुल्यकालिक कमांड निष्पादन प्रक्रिया को रद्द करने की अनुमति देना।

AsynchronousCommand की कुछ विशेषताओं का लाभ उठाएं। प्रत्येक AsynchronousCommand ऑब्जेक्ट में CancelCommand नामक एक कमांड भी होता है। और यह उपयोगकर्ता UI के लिए बाध्य हो सकता है या सही स्थान पर कोड के अंदर बुलाया जा सकता है। जब इस आदेश को कॉल किया जाता है, तो AsynchronousCommand ऑब्जेक्ट का IsCancellationRequested गुण सत्य पर सेट होता है (ध्यान दें कि संपत्ति INotifyPropertyChanged का उपयोग करती है और आपके पास इसे बाइंड करने का अवसर है)। आप समय-समय पर CancelIfRequested फ़ंक्शन को कॉल कर सकते हैं, और यदि यह अचानक सच हो जाता है, तो कमांड बंद हो जाएगी।

 public class MainViewModel : ViewModel { public MainViewModel() { //      cancellableAsyncCommand = new AsynchronousCommand( () => { for(int i = 1; i <= 100; i++) { // ? if(cancellableAsyncCommand.CancelIfRequested()) return; // . cancellableAsyncCommand.ReportProgress( () => { Messages.Add(i.ToString()); } ); System.Threading.Thread.Sleep(100); } }); } /// <summary> /// The command object. /// </summary> private AsynchronousCommand cancellableAsyncCommand; /// <summary> /// Gets the command. /// </summary> public AsynchronousCommand CancellableAsyncCommand { get { return cancellableAsyncCommand; } } } 

बटन के लिए कमांड बाँधें, और StackPanel को IsExecuting गुण:

 <Button Content="Cancellable Async Command" Command="{Binding CancellableAsyncCommand}" Visibility="{Binding CancellableAsyncCommand.IsExecuting, Converter={StaticResource BooleanToVisibilityConverter}, ConverterParameter=Invert}" /> <StackPanel Visibility="{Binding CancellableAsyncCommand.IsExecuting, Converter={StaticResource BooleanToVisibilityConverter}}"> <TextBlock Margin="4" Text="The command is running!" /> <ProgressBar Margin="4" Height="20" Width="120" IsIndeterminate="True" /> <Button Margin="4" Content="Cancel" Command="{Binding CancellableAsyncCommand.CancelCommand}" /> </StackPanel> 

इस उदाहरण में, हम कमांड के निष्पादन के दौरान रद्द करें बटन दिखाते हैं। यह बटन कैंसिलेबलएस्पांसकॉन्ड के साथ जुड़ा हुआ है। कैन्सेलेलमैंड प्रॉपर्टी। इस तथ्य के कारण कि हम CancelIfRequested फ़ंक्शन का उपयोग करते हैं, हमारे पास एक एसिंक्रोनस कमांड के निष्पादन को रोकने का एक सुंदर अवसर है।

नोट : जब आप एक एसिंक्रोनस कमांड को निष्पादित करना बंद कर देते हैं, तो एक्ज़क्यूटेड ईवेंट नहीं उठाया जाता है। हालाँकि, रद्द किया गया ईवेंट इसके बजाय बढ़ा है, जो समान पैरामीटर ले सकता है।

उद्देश्य : एक कमांड को सेट करें जब उपयोगकर्ता तत्व को सक्रिय किया जाए जिसमें कमांड प्रॉपर्टी सेट नहीं है लेकिन एक ईवेंट सेट है।

इस स्थिति में, आप EventBindings अनुलग्न गुण का उपयोग कर सकते हैं। यह Apex.Commands वर्ग में स्थित है। EventBindings एक EventBindingCollection स्वीकार करता है, जो EventBinding वस्तुओं का एक सरल संग्रह है। प्रत्येक EventBinding दो पैरामीटर लेता है: घटना का नाम और कमांड का नाम जिसे बुलाया जाना है।

 public class MainViewModel : ViewModel { public MainViewModel() { //    EventBindingCommand = new Command( () => { Messages.Add("  ."); }); } /// <summary> /// The command object. /// </summary> private Command eventBindingCommand; /// <summary> /// Gets the command. /// </summary> public Command EventBindingCommand { get { return eventBindingCommand; } } } 

घटना के लिए बाध्य टीम इस प्रकार है:

 <Border Margin="20" Background="Red"> <!—  EventBindingCommand   MouseLeftButtonDown. --> <apexCommands:EventBindings.EventBindings> <apexCommands:EventBindingCollection> <apexCommands:EventBinding EventName="MouseLeftButtonDown" Command="{Binding EventBindingCommand}" /> </apexCommands:EventBindingCollection> </apexCommands:EventBindings.EventBindings> <TextBlock VerticalAlignment="Center" HorizontalAlignment="Center" Text="Left Click on Me" FontSize="16" Foreground="White" /> </Border> 

EventBindings का उपयोग करते समय, किसी भी आदेश को किसी भी घटना से जोड़ा जा सकता है।

कमांड वर्ग पर विचार करें, जिसका उपयोग 1-5 उदाहरणों में किया गया था।

 /// <summary> ///  ViewModelCommand –   ICommand,   . /// </summary> public class Command : ICommand { /// <summary> ///       <see cref="Command"/>. /// </summary> /// <param name="action">.</param> /// <param name="canExecute">  <c>true</c> [can execute] ( ).</param> public Command(Action action, bool canExecute = true) { // Set the action. this.action = action; this.canExecute = canExecute; } /// <summary> ///       <see cref="Command"/> class. /// </summary> /// <param name="parameterizedAction"> .</param> /// <param name="canExecute">    <c>true</c> [can execute]( ).</param> public Command(Action<object> parameterizedAction, bool canExecute = true) { // Set the action. this.parameterizedAction = parameterizedAction; this.canExecute = canExecute; } 

सबसे पहले, हम दो अतिभारित निर्माणकर्ता बनाते हैं, जिसमें कार्रवाई को मापदंडों के बिना पारित किया जाता है: कार्रवाई, या मापदंडों के साथ: कार्रवाई <ऑब्जेक्ट>, जहां ऑब्जेक्ट एक प्रकार है।

अगला, canExecute ध्वज सेट करें, जो कमांड निष्पादित करने की क्षमता के लिए जिम्मेदार है। CanExecute फ्लैग बदलने के बाद, आपको canExecuteChanged कॉल करना होगा।

 /// <summary> /// (  )     . /// </summary> protected Action action = null; protected Action<object> parameterizedAction = null; /// <summary> ///  ,     . /// </summary> private bool canExecute = false; /// <summary> ///  /  ,      /// </summary> /// <value> /// <c>true</c>   ;   - <c>false</c>. /// </value> public bool CanExecute { get { return canExecute; } set { if (canExecute != value) { canExecute = value; EventHandler canExecuteChanged = CanExecuteChanged; if (canExecuteChanged != null) canExecuteChanged(this, EventArgs.Empty); } } } 

अगला, हम ICommand इंटरफ़ेस को लागू करते हैं

 /// <summary> ///  , ,        /// </summary> /// <param name="parameter">   . ///      , ///        null.</param> /// <returns> /// >    ;   - false. /// </returns> bool ICommand.CanExecute(object parameter) { return canExecute; } /// <summary> ///  ,      . /// </summary> /// <param name="parameter">    . ///      , ///        null.</param> void ICommand.Execute(object parameter) { this.DoExecute(parameter); } 

हम थोड़ी देर बाद DoExecute फ़ंक्शन का विश्लेषण करेंगे।

 /// <summary> /// ,      /// </summary> public event EventHandler CanExecuteChanged; /// <summary> ///      /// </summary> public event CancelCommandEventHandler Executing; /// <summary> /// ,    /// </summary> public event CommandEventHandler Executed; 

और अब हम प्रत्येक ईवेंट के लिए इनवोक फ़ंक्शन लागू करते हैं। इस प्रकार, हम उन्हें व्युत्पन्न वर्गों से कॉल करने में सक्षम होंगे।

 protected void InvokeAction(object param) { Action theAction = action; Action<object> theParameterizedAction = parameterizedAction; if (theAction != null) theAction(); else if (theParameterizedAction != null) theParameterizedAction(param); } protected void InvokeExecuted(CommandEventArgs args) { CommandEventHandler executed = Executed; //    if (executed != null) executed(this, args); } protected void InvokeExecuting(CancelCommandEventArgs args) { CancelCommandEventHandler executing = Executing; // Call the executed event. if (executing != null) executing(this, args); } 

नोट : InvokeAction मापदंडों के बिना या तो मापदंडों के साथ एक क्रिया कहता है, जिसके आधार पर कोई भी सेट किया जाता है।

 /// <summary> ///   /// </summary> /// <param name="param">The param.</param> public virtual void DoExecute(object param) { //       CancelCommandEventArgs args = new CancelCommandEventArgs() { Parameter = param, Cancel = false }; InvokeExecuting(args); //     - . if (args.Cancel) return; //    /  ,    .   . InvokeAction(param); // Call the executed function. InvokeExecuted(new CommandEventArgs() { Parameter = param }); } 

DoExecute काफी सरल है। यह निष्पादन को रद्द करने की क्षमता के साथ बस इसी घटना को उठाता है।

उपरोक्त वर्ग ICommand इंटरफ़ेस को लागू करता है और 1-5 उदाहरणों में प्रयुक्त सभी आवश्यक कार्यक्षमता प्रदान करता है।

उदाहरण 6-8 में एसिंक्रोनसकॉसमंड वर्ग का उपयोग किया गया है, जो बदले में ऊपर वर्णित कमांड वर्ग को विरासत में मिला है।

सबसे पहले, हम बॉक्स ऑफिस और कंस्ट्रक्टर की घोषणा करते हैं:

 /// <summary> ///   -  ,        .. /// </summary> public class AsynchronousCommand : Command, INotifyPropertyChanged { /// <summary> ///       <see cref="AsynchronousCommand"/>. /// </summary> /// <param name="action">.</param> /// <param name="canExecute">    /// <c>true</c>   .</param> public AsynchronousCommand(Action action, bool canExecute = true) : base(action, canExecute) { //   Initialise(); } /// <summary> ///      <see cref="AsynchronousCommand"/>. /// </summary> /// <param name="parameterizedAction"> .</param> /// <param name="canExecute">    <c>true</c> [can execute] ( ).</param> public AsynchronousCommand(Action<object> parameterizedAction, bool canExecute = true) : base(parameterizedAction, canExecute) { //   Initialise(); } 

INotifyPropertyChanged IsExecuting. Initialise, :

 /// <summary> ///   /// </summary> private Command cancelCommand; /// <summary> ///   . /// </summary> public Command CancelCommand { get { return cancelCommand; } } /// <summary> /// / , ,     /// </summary> /// <value> /// <c>true</c>     ;   - <c>false</c>. /// </value> public bool IsCancellationRequested { get { return isCancellationRequested; } set { if (isCancellationRequested != value) { isCancellationRequested = value; NotifyPropertyChanged("IsCancellationRequested"); } } } /// <summary> ///   /// </summary> private void Initialise() { //    cancelCommand = new Command( () => { // Set the Is Cancellation Requested flag. IsCancellationRequested = true; }, true); } 

, , — IsCancellationRequested true. . IsCancellationRequested, , .

, . निम्नलिखित कोड जोड़ें:

 /// <summary> /// , ,     . /// </summary> private bool isExecuting = false; /// <summary> /// / ,  ,     .. /// </summary> /// <value> /// <c>true</c>    ;  <c>false</c>. /// </value> public bool IsExecuting { get { return isExecuting; } set { if (isExecuting != value) { isExecuting = value; NotifyPropertyChanged("IsExecuting"); } } } 

चलिए जारी रखते हैं। Cancelled PropertyChanged ( INotifyPropertyChanged):

 /// <summary> /// The property changed event. /// </summary> public event PropertyChangedEventHandler PropertyChanged; /// <summary> /// ,   . /// </summary> public event CommandEventHandler Cancelled;      DoExecute. /// <summary> ///  . /// </summary> /// <param name="param">.</param> public override void DoExecute(object param) { //     ,  . if (IsExecuting) return; //   ,     . CancelCommandEventArgs args = new CancelCommandEventArgs() { Parameter = param, Cancel = false }; InvokeExecuting(args); //   - . if (args.Cancel) return; //   . IsExecuting = true; 

, , .

 //   . #if !SILVERLIGHT callingDispatcher = Dispatcher.CurrentDispatcher; #else callingDispatcher = System.Windows.Application.Current.RootVisual.Dispatcher; #endif 

, , .

, Silverlight WPF.

 // Run the action on a new thread from the thread pool // (this will therefore work in SL and WP7 as well). ThreadPool.QueueUserWorkItem( (state) => { //  . InvokeAction(param); // Fire the executed event and set the executing state. ReportProgress( () => { //     . IsExecuting = false; //  , //    - ,   –  . if(IsCancellationRequested) InvokeCancelled(new CommandEventArgs() { Parameter = param }); else InvokeExecuted(new CommandEventArgs() { Parameter = param }); //    . IsCancellationRequested = false; } ); } ); } 

. , InvokeAction , . , ReportProgress , Executed. ( ), IsExecuting, : Cancelled Executed. , ReportProgress:

 /// <summary> /// Reports progress on the thread which invoked the command. /// </summary> /// <param name="action">The action.</param> public void ReportProgress(Action action) { if (IsExecuting) { if (callingDispatcher.CheckAccess()) action(); else callingDispatcher.BeginInvoke(((Action)(() => { action(); }))); } } 

EventBindings - WPF Silverlight. WPF EventBindingsCollection FreezableCollection, . Silverlight FreezableCollection, .

 public static class EventBindings { /// <summary> ///  Event Bindings. /// </summary> private static readonly DependencyProperty EventBindingsProperty = DependencyProperty.RegisterAttached("EventBindings", typeof(EventBindingCollection), typeof(EventBindings), new PropertyMetadata(null, new PropertyChangedCallback(OnEventBindingsChanged))); /// <summary> /// Gets the event bindings. /// </summary> /// <param name="o">The o.</param> /// <returns></returns> public static EventBindingCollection GetEventBindings(DependencyObject o) { return (EventBindingCollection)o.GetValue(EventBindingsProperty); } /// <summary> /// Sets the event bindings. /// </summary> /// <param name="o">The o.</param> /// <param name="value">The value.</param> public static void SetEventBindings(DependencyObject o, EventBindingCollection value) { o.SetValue(EventBindingsProperty, value); } /// <summary> /// Called when event bindings changed. /// </summary> /// <param name="o">The o.</param> /// <param name="args">The <see /// cref="System.Windows.DependencyPropertyChangedEventArgs"/> /// instance containing the event data.</param> public static void OnEventBindingsChanged(DependencyObject o, DependencyPropertyChangedEventArgs args) { // Cast the data. EventBindingCollection oldEventBindings = args.OldValue as EventBindingCollection; EventBindingCollection newEventBindings = args.NewValue as EventBindingCollection; // If we have new set of event bindings, bind each one. if (newEventBindings != null) { foreach (EventBinding binding in newEventBindings) { binding.Bind(o); #if SILVERLIGHT // If we're in Silverlight we don't inherit the // data context so we must set this helper variable. binding.ParentElement = o as FrameworkElement; #endif } } } } 

EventBinding.Bind:

 public void Bind(object o) { try { //        EventInfo eventInfo = o.GetType().GetEvent(EventName); // Get the method info for the event proxy. MethodInfo methodInfo = GetType().GetMethod("EventProxy", BindingFlags.NonPublic | BindingFlags.Instance); // Create a delegate for the event to the event proxy. Delegate del = Delegate.CreateDelegate(eventInfo.EventHandlerType, this, methodInfo); // Add the event handler. (Removing it first if it already exists!) eventInfo.RemoveEventHandler(o, del); eventInfo.AddEventHandler(o, del); } catch (Exception e) { string s = e.ToString(); } } /// <summary> /// Proxy to actually fire the event. /// </summary> /// <param name="o">The object.</param> /// <param name="e">The <see /// cref="System.EventArgs"/> instance /// containing the event data.</param> private void EventProxy(object o, EventArgs e) { #if SILVERLIGHT // If we're in Silverlight, we have NOT inherited the data context // because the EventBindingCollection is not a framework element and // therefore out of the logical tree. However, we can set it here // and update the bindings - and it will all work. DataContext = ParentElement != null ? ParentElement.DataContext : null; var bindingExpression = GetBindingExpression(EventBinding.CommandProperty); if(bindingExpression != null) bindingExpression.UpdateSource(); bindingExpression = GetBindingExpression(EventBinding.CommandParameterProperty); if (bindingExpression != null) bindingExpression.UpdateSource(); #endif if (Command != null) Command.Execute(CommandParameter); }