Aracılığıyla paylaş

Yönetim Genel Bakış

Komut, Windows Presentation Foundation'da (WPF) cihaz girişinden daha anlamsal düzeyde giriş işleme sağlayan bir giriş mekanizmasıdır. Komutlara örnek olarak birçok uygulamada bulunan Kopyala, Kes ve Yapıştır işlemleri verilebilir.

Bu genel bakış, WPF'de hangi komutların olduğunu, hangi sınıfların komut modelinin parçası olduğunu ve uygulamalarınızda komutların nasıl kullanılacağını ve oluşturulacağını tanımlar.

Bu konu aşağıdaki bölümleri içerir:

Komutlar Nelerdir?

Komutların çeşitli amaçları vardır. İlk amaç, semantiği ve komutu çağıran nesneyi komutu yürüten mantıktan ayırmaktır. Bu, birden çok ve farklı kaynağın aynı komut mantığını çağırmasına olanak tanır ve komut mantığının farklı hedefler için özelleştirilmesine olanak tanır. Örneğin, birçok uygulamada bulunan Kopyalama, Kesme ve Yapıştırma düzenleme işlemleri, komutlar kullanılarak uygulanıyorsa farklı kullanıcı eylemleri kullanılarak çağrılabilir. Uygulama, kullanıcının bir düğmeye tıklayarak, menüden bir öğe seçerek veya CTRL+X gibi bir tuş bileşimi kullanarak seçili nesneleri veya metni kesmesine izin verebilir. Komutları kullanarak her kullanıcı eylemi türünü aynı mantığa bağlayabilirsiniz.

Komutların bir diğer amacı da bir eylemin kullanılabilir olup olmadığını belirtmektir. Nesne veya metin kesme örneğine devam etmek için, eylem yalnızca bir şey seçildiğinde mantıklı olur. Kullanıcı hiçbir şey seçmeden bir nesneyi veya metni kesmeye çalışırsa hiçbir şey olmaz. Bunu kullanıcıya göstermek için, birçok uygulama düğmeleri ve menü öğelerini devre dışı bırakır, böylece kullanıcı eylem gerçekleştirmenin mümkün olup olmadığını bilir. Bir komut, CanExecute yöntemini uygulayarak bir eylemin mümkün olup olmadığını belirtebilir. Bir düğme CanExecuteChanged olayına abone olabilir ve CanExecute döndürürse false devre dışı bırakılabilir veya CanExecute döndürürse true etkinleştirilebilir.

Bir komutun semantiği uygulamalar ve sınıflar arasında tutarlı olabilir, ancak eylemin mantığı üzerinde işlem yapılan belirli nesneye özgüdür. CTRL+X tuş bileşimi metin sınıflarında, görüntü sınıflarında ve Web tarayıcılarında Kes komutunu çağırır, ancak Kesme işlemini gerçekleştirmek için gerçek mantık kesme işlemini gerçekleştiren uygulama tarafından tanımlanır. A RoutedCommand , istemcilerin mantığı uygulamasına olanak tanır. Metin nesnesi seçili metni panoya kesebilirken, resim nesnesi seçili görüntüyü kesebilir. Bir uygulama olayı işlediğinde Executed , komutun hedefine erişebilir ve hedefin türüne bağlı olarak uygun eylemi gerçekleştirebilir.

WPF'de Basit Komut Örneği

WPF'de komut kullanmanın en basit yolu, komut kitaplığı sınıflarından birinden önceden tanımlanmış RoutedCommand bir denetim kullanmak; komutu işlemek için yerel desteğe sahip bir denetim kullanmak ve komutu çağırmak için yerel desteğe sahip bir denetim kullanmaktır. Paste komutu, sınıfındaki önceden tanımlanmış komutlardan ApplicationCommands biridir. TextBox denetimi, Paste komutunu işlemek için yerleşik bir mantığa sahiptir. Ayrıca sınıfı, MenuItem komutları çağırmak için yerel desteğe sahiptir.

Aşağıdaki örnek, klavye odağı MenuItem üzerinde olduğunda Paste tıklandığında TextBox üzerinde TextBox komutunun nasıl çağrılacağını göstermektedir.

<StackPanel>
  <Menu>
    <MenuItem Command="ApplicationCommands.Paste" />
  </Menu>
  <TextBox />
</StackPanel>

// Creating the UI objects
StackPanel mainStackPanel = new StackPanel();
TextBox pasteTextBox = new TextBox();
Menu stackPanelMenu = new Menu();
MenuItem pasteMenuItem = new MenuItem();

// Adding objects to the panel and the menu
stackPanelMenu.Items.Add(pasteMenuItem);
mainStackPanel.Children.Add(stackPanelMenu);
mainStackPanel.Children.Add(pasteTextBox);

// Setting the command to the Paste command
pasteMenuItem.Command = ApplicationCommands.Paste;

// Setting the command target to the TextBox
pasteMenuItem.CommandTarget = pasteTextBox;

' Creating the UI objects
Dim mainStackPanel As New StackPanel()
Dim pasteTextBox As New TextBox()
Dim stackPanelMenu As New Menu()
Dim pasteMenuItem As New MenuItem()

' Adding objects to the panel and the menu
stackPanelMenu.Items.Add(pasteMenuItem)
mainStackPanel.Children.Add(stackPanelMenu)
mainStackPanel.Children.Add(pasteTextBox)

' Setting the command to the Paste command
pasteMenuItem.Command = ApplicationCommands.Paste

WPF Komutlarında Dört Ana Kavram

WPF'de yönlendirilen komut modeli dört ana kavrama ayrılabilir: komut, komut kaynağı, komut hedefi ve komut bağlaması:

  • Komut yürütülecek eylemdir.

  • Komut kaynağı, komutu çağıran nesnedir.

  • Komut hedefi, komutun yürütülmekte olduğu nesnedir.

  • Komut bağlaması, komut mantığını komutla eşleyen nesnedir.

Önceki örnekte Paste komut komutudur, MenuItem komut kaynağıdır, TextBox komut hedefidir ve komut bağlaması denetim tarafından TextBox sağlanır. Belirtmekte fayda var ki, her zaman komut hedef sınıfı olan denetim tarafından CommandBinding sağlanmaz. Genellikle uygulama CommandBinding geliştiricisi tarafından oluşturulması gerekir veya CommandBinding komut hedefinin bir atasına ilişkili olabilir.

Komutlar

WPF'deki komutlar, ICommand arabirimi uygulanarak oluşturulur. ICommand adlı iki yöntem, Execute ve CanExecute, ve bir olay, CanExecuteChanged, kullanıma sunar. Execute komutuyla ilişkili eylemleri gerçekleştirir. CanExecute komutun geçerli komut hedefinde yürütülip yürütülemeyeceğini belirler. CanExecuteChanged , komut işlemlerini merkezileştiren komut yöneticisi komut kaynağında, komut bağlaması tarafından oluşturulmuş ancak henüz yürütülmemiş bir komutu geçersiz kabilecek bir değişiklik algılarsa oluşturulur. WPF'nin ICommand uygulaması RoutedCommand sınıfıdır ve bu genel bakışın odağıdır.

WPF'deki ana giriş kaynakları fare, klavye, mürekkep ve yönlendirilmiş komutlardır. Cihaz odaklı girişler, uygulama sayfasındaki nesnelere bir giriş olayının gerçekleştiğini bildirmek için kullanır RoutedEvent . A RoutedCommand farklı değildir. Execute ve CanExecute yöntemleri, RoutedCommand komutu için uygulama mantığını içermez; bunun yerine, öğe ağacında bir CommandBinding nesnesiyle karşılaşana kadar tünel ve baloncuklama yoluyla yönlendirilmiş olaylar başlatırlar. CommandBinding, bu olayların işleyicilerini içerir ve komutu gerçekleştiren ise bu işleyicilerdir. WPF'de olay yönlendirme hakkında daha fazla bilgi için bkz. Yönlendirilmiş Olaylara Genel Bakış.

Execute yöntemi, RoutedCommand üzerinde, komut hedefinde PreviewExecuted ve Executed olaylarını tetikler. CanExecute üzerindeki RoutedCommand yöntemi, komut hedefinde CanExecute ve PreviewCanExecute olaylarını tetikler. Bu olaylar, belirli bir komuta sahip CommandBinding bir nesneyle karşılaşana kadar öğe ağacında tünel yapar ve kabarcık oluşturur.

WPF, çeşitli sınıflara yayılmış bir dizi ortak yönlendirilmiş komut sağlar: MediaCommands, ApplicationCommands, NavigationCommands, ComponentCommandsve EditingCommands. Bu sınıflar komutun RoutedCommand uygulama mantığından değil yalnızca nesnelerden oluşur. Uygulama mantığı, komutun yürütülmekte olduğu nesnenin sorumluluğundadır.

Komut Kaynakları

Komut kaynağı, komutu çağıran nesnedir. Komut kaynaklarına örnek olarak MenuItem, Buttonve KeyGestureverilebilir.

WPF'deki komut kaynakları genellikle ICommandSource arabirimini uygular.

ICommandSource üç özelliği kullanıma sunar: Command, CommandTargetve CommandParameter:

ICommandSource'yu uygulayan WPF sınıfları, ButtonBase, MenuItem, Hyperlink, ve InputBinding'dir. ButtonBase, MenuItem ve Hyperlink tıklandığında bir komutu çağırır; InputBinding ile ilişkilendirilmiş olan bir InputGesture ise gerçekleştirildiğinde bir komutu çağırır.

Aşağıdaki örnek, bir MenuItem 'in ContextMenu içinde Properties komutu için komut kaynağı olarak nasıl kullanılacağını gösterir.

<StackPanel>
  <StackPanel.ContextMenu>
    <ContextMenu>
      <MenuItem Command="ApplicationCommands.Properties" />
    </ContextMenu>
  </StackPanel.ContextMenu>
</StackPanel>

StackPanel cmdSourcePanel = new StackPanel();
ContextMenu cmdSourceContextMenu = new ContextMenu();
MenuItem cmdSourceMenuItem = new MenuItem();

// Add ContextMenu to the StackPanel.
cmdSourcePanel.ContextMenu = cmdSourceContextMenu;
cmdSourcePanel.ContextMenu.Items.Add(cmdSourceMenuItem);

// Associate Command with MenuItem.
cmdSourceMenuItem.Command = ApplicationCommands.Properties;

Dim cmdSourcePanel As New StackPanel()
Dim cmdSourceContextMenu As New ContextMenu()
Dim cmdSourceMenuItem As New MenuItem()

' Add ContextMenu to the StackPanel.
cmdSourcePanel.ContextMenu = cmdSourceContextMenu
cmdSourcePanel.ContextMenu.Items.Add(cmdSourceMenuItem)

' Associate Command with MenuItem.
cmdSourceMenuItem.Command = ApplicationCommands.Properties

Genellikle bir komut kaynağı CanExecuteChanged olayını dinler. Bu olay, komutun geçerli komut hedefinde yürütülebilme özelliğinin değişmiş olabileceğini komut kaynağına bildirir. Komut kaynağı yöntemini kullanarak RoutedCommand öğesinin CanExecute geçerli durumunu sorgulayabilir. Komut yürütülemezse komut kaynağı kendisini devre dışı bırakabilir. Bunun bir örneği, bir komut yürütülemediğinde MenuItem'in griye dönüşerek kendisini etkisiz hale getirmesidir.

bir InputGesture komut kaynağı olarak kullanılabilir. WPF'de iki tür giriş hareketi KeyGesture ve MouseGesture'dir. CTRL+C gibi bir klavye kısayolu olarak düşünebilirsiniz KeyGesture . A KeyGesture , bir Key ve kümesinden ModifierKeysoluşur. A MouseGesture, bir MouseAction ve isteğe bağlı bir ModifierKeys kümesinden oluşur.

komut InputGesture kaynağı olarak davranabilmesi için bir komutla ilişkilendirilmesi gerekir. Bunu yapmanın birkaç yolu vardır. Bunun bir yolu, kullanmaktır InputBinding.

Aşağıdaki örnek, KeyBinding ile KeyGesture arasında bir RoutedCommand oluşturmaya nasıl gösterir.

<Window.InputBindings>
  <KeyBinding Key="B"
              Modifiers="Control" 
              Command="ApplicationCommands.Open" />
</Window.InputBindings>

KeyGesture OpenKeyGesture = new KeyGesture(
    Key.B,
    ModifierKeys.Control);

KeyBinding OpenCmdKeybinding = new KeyBinding(
    ApplicationCommands.Open,
    OpenKeyGesture);

this.InputBindings.Add(OpenCmdKeybinding);

Dim OpenKeyGesture As New KeyGesture(Key.B, ModifierKeys.Control)

Dim OpenCmdKeybinding As New KeyBinding(ApplicationCommands.Open, OpenKeyGesture)

Me.InputBindings.Add(OpenCmdKeybinding)

InputGesture ile RoutedCommand ilişkilendirmenin bir başka yolu, InputGesture üzerinde InputGestureCollection'e RoutedCommand eklemektir.

Aşağıdaki örnek, KeyGesture öğesinin InputGestureCollection bölümüne bir RoutedCommand'nın nasıl ekleneceğini göstermektedir.

KeyGesture OpenCmdKeyGesture = new KeyGesture(
    Key.B,
    ModifierKeys.Control);

ApplicationCommands.Open.InputGestures.Add(OpenCmdKeyGesture);

Dim OpenCmdKeyGesture As New KeyGesture(Key.B, ModifierKeys.Control)

ApplicationCommands.Open.InputGestures.Add(OpenCmdKeyGesture)

Komut Bağlama

komutu CommandBinding , komutu uygulayan olay işleyicileriyle ilişkilendirir.

CommandBinding sınıfı bir Command özellik ve PreviewExecuted, Executed, PreviewCanExecuteve CanExecute olayları içerir.

Command, CommandBinding ile ilişkilendirilen komuttur. ve PreviewExecuted olaylarına Executed eklenen olay işleyicileri komut mantığını uygular. PreviewCanExecute ve CanExecute olaylarına eklenen olay işleyicileri, komutun geçerli komut hedefinde yürütülüp yürütülemeyeceğini belirler.

Aşağıdaki örnek, bir uygulamanın kökünde CommandBinding üzerine bir Window nasıl oluşturulacağını göstermektedir. CommandBinding Open komutunu Executed ve CanExecute işleyicileriyle ilişkilendirir.

<Window.CommandBindings>
  <CommandBinding Command="ApplicationCommands.Open"
                  Executed="OpenCmdExecuted"
                  CanExecute="OpenCmdCanExecute"/>
</Window.CommandBindings>

// Creating CommandBinding and attaching an Executed and CanExecute handler
CommandBinding OpenCmdBinding = new CommandBinding(
    ApplicationCommands.Open,
    OpenCmdExecuted,
    OpenCmdCanExecute);

this.CommandBindings.Add(OpenCmdBinding);

' Creating CommandBinding and attaching an Executed and CanExecute handler
Dim OpenCmdBinding As New CommandBinding(ApplicationCommands.Open, AddressOf OpenCmdExecuted, AddressOf OpenCmdCanExecute)

Me.CommandBindings.Add(OpenCmdBinding)

Ardından ExecutedRoutedEventHandler ve bir CanExecuteRoutedEventHandler oluşturulur. ExecutedRoutedEventHandler , komutun yürütüldüğünü belirten bir dizeyi görüntüleyen bir MessageBox açar. CanExecuteRoutedEventHandler, CanExecute özelliğini trueolarak ayarlar.

void OpenCmdExecuted(object target, ExecutedRoutedEventArgs e)
{
    String command, targetobj;
    command = ((RoutedCommand)e.Command).Name;
    targetobj = ((FrameworkElement)target).Name;
    MessageBox.Show("The " + command +  " command has been invoked on target object " + targetobj);
}

Private Sub OpenCmdExecuted(ByVal sender As Object, ByVal e As ExecutedRoutedEventArgs)
    Dim command, targetobj As String
    command = CType(e.Command, RoutedCommand).Name
    targetobj = CType(sender, FrameworkElement).Name
    MessageBox.Show("The " + command + " command has been invoked on target object " + targetobj)
End Sub

void OpenCmdCanExecute(object sender, CanExecuteRoutedEventArgs e)
{
    e.CanExecute = true;
}

Private Sub OpenCmdCanExecute(ByVal sender As Object, ByVal e As CanExecuteRoutedEventArgs)
    e.CanExecute = True
End Sub

, CommandBinding uygulamanın kökü Window veya denetim gibi belirli bir nesneye eklenir. öğesinin CommandBinding eklendiği nesne bağlamanın kapsamını tanımlar. Örneğin, bir komut hedefinin atasına bağlı olan CommandBinding bir olay Executed tarafından erişilebilirken, komut hedefinin bir alt öğesine iliştirilmiş CommandBinding bir olaya ulaşılamaz. Bu, olayı oluşturan nesneden kaynaklanan RoutedEvent tünel ve kabarcık mekanizmalarının doğrudan bir sonucudur.

Bazı durumlarda, CommandBinding doğrudan komut hedefinin kendisine eklenir, örneğin TextBox sınıfı ve Cut, Copy, Paste komutları ile. Yine de, özellikle aynı CommandBinding birden çok komut hedefi için kullanılabiliyorsa, Window öğesini komut hedefinin bir atası olarak ana CommandBinding veya Uygulama nesnesine eklemek daha uygundur. Bunlar, komut altyapınızı oluştururken dikkate almak isteyeceğiniz tasarım kararlarıdır.

Komut Hedefi

Komut hedefi, komutun yürütüldiği öğedir. RoutedCommand ile ilgili olarak, komut hedefi, Executed ve CanExecute yönlendirmesinin başlatıldığı öğedir. Daha önce belirtildiği gibi, WPF'de CommandTarget bir ICommandSource olduğunda, ICommand üzerindeki RoutedCommand özelliği yalnızca geçerlidir. Eğer bir CommandTarget bir ICommandSource üzerinde ayarlanırsa ve ilgili komut bir RoutedCommand değilse, komut hedefi yoksayılır.

Komut kaynağı, komut hedefini açıkça ayarlayabilir. Komut hedefi tanımlanmamışsa, komut hedefi olarak klavye odağına sahip öğe kullanılır. Komut hedefi olarak klavye odağıyla öğesini kullanmanın avantajlarından biri, uygulama geliştiricisinin komut hedefini izlemek zorunda kalmadan birden çok hedefte bir komut çağırmak için aynı komut kaynağını kullanmasına izin vermesidir. Örneğin, MenuItem bir Yapıştır komutunu çağırdığında TextBox ve PasswordBox kontrolü olan bir uygulamada, hedef, klavye odağının hangi kontrol üzerinde olduğuna bağlı olarak ya TextBox ya da PasswordBox olabilir.

Aşağıdaki örnekte, işaretlemede ve arkasındaki kodda komut hedefinin açıkça nasıl ayarlanacağı gösterilmektedir.

<StackPanel>
  <Menu>
    <MenuItem Command="ApplicationCommands.Paste"
              CommandTarget="{Binding ElementName=mainTextBox}" />
  </Menu>
  <TextBox Name="mainTextBox"/>
</StackPanel>

// Creating the UI objects
StackPanel mainStackPanel = new StackPanel();
TextBox pasteTextBox = new TextBox();
Menu stackPanelMenu = new Menu();
MenuItem pasteMenuItem = new MenuItem();

// Adding objects to the panel and the menu
stackPanelMenu.Items.Add(pasteMenuItem);
mainStackPanel.Children.Add(stackPanelMenu);
mainStackPanel.Children.Add(pasteTextBox);

// Setting the command to the Paste command
pasteMenuItem.Command = ApplicationCommands.Paste;

// Setting the command target to the TextBox
pasteMenuItem.CommandTarget = pasteTextBox;

' Creating the UI objects
Dim mainStackPanel As New StackPanel()
Dim pasteTextBox As New TextBox()
Dim stackPanelMenu As New Menu()
Dim pasteMenuItem As New MenuItem()

' Adding objects to the panel and the menu
stackPanelMenu.Items.Add(pasteMenuItem)
mainStackPanel.Children.Add(stackPanelMenu)
mainStackPanel.Children.Add(pasteTextBox)

' Setting the command to the Paste command
pasteMenuItem.Command = ApplicationCommands.Paste

Komut Yöneticisi

, CommandManager komutla ilgili bir dizi işleve hizmet eder. Belirli bir öğeye PreviewExecuted, Executed, PreviewCanExecute ve CanExecute olay işleyicileri eklemek ve çıkarmak için bir dizi statik yöntem sağlar. Belirli bir sınıfa CommandBinding ve InputBinding nesnelerini kaydetmek için bir araç sağlar. ayrıca CommandManager, RequerySuggested olayı aracılığıyla, bir komuta CanExecuteChanged olayının ne zaman tetiklenmesi gerektiğini bildirmek için bir yol sağlar.

InvalidateRequerySuggested yöntemi, CommandManager'i RequerySuggested olayını tetiklemeye zorlar. Bu, bir komutu devre dışı bırakması veya etkinleştirmesi gereken ancak CommandManager'in farkında olmadığı koşullar için yararlıdır.

Komut Kitaplığı

WPF önceden tanımlanmış bir komut kümesi sağlar. Komut kitaplığı şu sınıflardan oluşur: ApplicationCommands, NavigationCommands, MediaCommands, EditingCommandsve .ComponentCommands Bu sınıflar Cut, BrowseBack, BrowseForward, Play, Stop ve Pause gibi komutlar sağlar.

Bu komutların çoğu bir dizi varsayılan giriş bağlaması içerir. Örneğin, uygulamanızın kopyalama komutunu işlediğini belirtirseniz, "CTRL+C" klavye bağlamasını otomatik olarak alırsınız. Ayrıca Tablet PC kalem hareketleri ve konuşma bilgileri gibi diğer giriş cihazları için bağlamalar da alırsınız.

XAML kullanarak çeşitli komut kitaplıklarındaki komutlara başvurduğunuz zaman, genellikle statik komut özelliğini kullanıma sunan kitaplık sınıfının sınıf adını atlayabilirsiniz. Genellikle, komut adları dizeler olarak belirsizdir ve komutlardan oluşan mantıksal bir gruplandırma sağlamak için sahip olan türler vardır, ancak kesinleştirme için gerekli değildir. Örneğin, daha ayrıntılı olan Command="Cut" yerine Command="ApplicationCommands.Cut" belirtebilirsiniz. Bu, WPF XAML işlemcisinde komutlar için yerleşik bir kolaylık mekanizmasıdır (daha spesifik olarak, WPF XAML işlemcisinin yükleme sırasında başvurduğu ICommand türü dönüştürücü davranışıdır).

Özel Komutlar Oluşturma

Komut kitaplığı sınıflarındaki komutlar gereksinimlerinizi karşılamıyorsa kendi komutlarınızı oluşturabilirsiniz. Özel komut oluşturmanın iki yolu vardır. İlki sıfırdan başlayıp arabirimi uygulamaktır ICommand . Diğer bir yol ve daha yaygın yaklaşım, bir RoutedCommand veya bir RoutedUICommand oluşturmaktır.

Özel RoutedCommandoluşturma örneği için bkz. Özel Yönlendirilmiş Komut Örneği Oluşturma.

Ayrıca bakınız