Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort zur 5. Auflage
1 Allgemeine Einführung in .NET
2 Grundlagen der Sprache C#
3 Klassendesign
4 Vererbung, Polymorphie und Interfaces
5 Delegates und Ereignisse
6 Weitere .NET-Datentypen
7 Weitere Möglichkeiten von C#
8 Auflistungsklassen (Collections)
9 Fehlerbehandlung und Debugging
10 LINQ to Objects
11 Multithreading und die Task Parallel Library (TPL)
12 Arbeiten mit Dateien und Streams
13 Binäre Serialisierung
14 Einige wichtige .NET-Klassen
15 Projektmanagement und Visual Studio 2010
16 XML
17 WPF – Die Grundlagen
18 WPF-Containerelemente
19 WPF-Steuerelemente
20 Konzepte der WPF
21 Datenbindung
22 2D-Grafik
23 ADO.NET – verbindungsorientierte Objekte
24 ADO.NET – Das Command-Objekt
25 ADO.NET – Der SqlDataAdapter
26 ADO.NET – Daten im lokalen Speicher
27 ADO.NET – Aktualisieren der Datenbank
28 Stark typisierte DataSets
29 LINQ to SQL
30 Weitergabe von Anwendungen
Stichwort

Buch bestellen
Ihre Meinung?

Spacer
<< zurück
Visual C# 2010 von Andreas Kühnel
Das umfassende Handbuch
Buch: Visual C# 2010

Visual C# 2010
geb., mit DVD
1295 S., 49,90 Euro
Rheinwerk Computing
ISBN 978-3-8362-1552-7
Pfeil 20 Konzepte der WPF
Pfeil 20.1 Ressourcen
Pfeil 20.1.1 Wo logische Ressourcen definiert werden können
Pfeil 20.1.2 Definition logischer Ressourcen
Pfeil 20.1.3 Statische und dynamische Ressourcen
Pfeil 20.1.4 Ressourcen in Ressourcendateien
Pfeil 20.1.5 Suche nach einer Ressource
Pfeil 20.1.6 Ressourcen mit C#-Code
Pfeil 20.1.7 Abrufen von Systemressourcen
Pfeil 20.2 Styles
Pfeil 20.2.1 Einfache Stile
Pfeil 20.2.2 Typisierte Stile
Pfeil 20.2.3 EventSetter
Pfeil 20.3 Trigger
Pfeil 20.3.1 Eigenschaftstrigger
Pfeil 20.3.2 Ereignistrigger
Pfeil 20.3.3 Datentrigger
Pfeil 20.4 Templates
Pfeil 20.4.1 Grundlagen der Templates
Pfeil 20.4.2 Verfeinerung des Entwurfs
Pfeil 20.4.3 Definition innerhalb eines Styles
Pfeil 20.4.4 Den Visual Tree ermitteln
Pfeil 20.5 Commands
Pfeil 20.5.1 Vordefinierte Commands
Pfeil 20.5.2 Beispielanwendung
Pfeil 20.5.3 Commando-Ziel festlegen
Pfeil 20.5.4 Commands an Ereignisse binden
Pfeil 20.5.5 Commands programmieren


Galileo Computing - Zum Seitenanfang

20.5 Commands Zur nächsten ÜberschriftZur vorigen Überschrift

Viele Operationen müssen Sie in nahezu jeder Anwendung neu implementieren: das Kopieren von Daten in die Zwischenablage, das Ausschneiden von markiertem Text, das Speichern von Änderungen usw. WPF vereinfacht die Codierungsarbeit dadurch, dass Ihnen eine große Zahl bereits vorgefertigter Operationen zur Verfügung gestellt werden. Entwickeln Sie beispielsweise ein Menü mit dem Hauptmenüpunkt Bearbeiten und den untergeordneten Elementen Kopieren, Ausschneiden und Einfügen, brauchen Sie nur auf die vordefinierten Kommandos zurückzugreifen.


Galileo Computing - Zum Seitenanfang

20.5.1 Vordefinierte Commands Zur nächsten ÜberschriftZur vorigen Überschrift

Die von WPF bereitgestellten Commands lassen sich in sechs Kategorien unterteilen. Jede Kategorie wird durch eine Klasse beschrieben, die wir uns nun anschauen wollen:

  • AnnotationService (im Namespace System.Windows.Annotations)
  • ApplicationCommands (im Namespace System.Windows.Input)
  • ComponentCommands (im Namespace System.Windows.Input)
  • EditingCommands (im Namespace System.Windows.Documents)
  • MediaCommands (im Namespace System.Windows.Input)
  • NavigationCommands (im Namespace System.Windows.Input)

Die einzelnen Commands werden in den Klassen als statische Eigenschaften bereitgestellt. Sie sind alle vom Typ RoutedUICommand.

Ihnen hier alle Commands vorzustellen, würde den Rahmen dieses Kapitels sprengen. Stattdessen möchte ich Ihnen einige wichtige Commands aus ApplicationCommands vorstellen, damit Sie ein Gefühl dafür bekommen, welche Möglichkeiten Ihnen mit Commands eröffnet werden.


Tabelle 20.1 Vordefinierte Commands in der Klasse »ApplicationCommands« (Auszug)

Command Beschreibung
Close

Stellt den Close-Befehl dar.

ContextMenu

Stellt den ContextMenu-Befehl dar.

Copy

Stellt den Copy-Befehl dar.

Cut

Stellt den Cut-Befehl dar.

Delete

Stellt den Delete-Befehl dar.

Find

Stellt den Find-Befehl dar.

Open

Stellt den Open-Befehl dar.

Paste

Stellt den Paste-Befehl dar.

Print

Stellt den Print-Befehl dar.

Redo

Stellt den Redo-Befehl dar.

Save

Stellt den Save-Befehl dar.

Undo

Stellt den Undo-Befehl dar.



Galileo Computing - Zum Seitenanfang

20.5.2 Beispielanwendung Zur nächsten ÜberschriftZur vorigen Überschrift

An einem Beispiel wollen wir uns nun ansehen, wie Commands eingesetzt werden. Dazu wird in einem Window eine Menüleiste bereitgestellt, die die Menüpunkte Datei und Bearbeiten enthält. Der Fensterbereich wird durch zwei TextBoxen beansprucht.


// ---------------------------------------------------------
// Beispiel: ...\Kapitel 20\ApplicationCommandDemo
// ---------------------------------------------------------
<Window ...>
  <DockPanel>
    <Menu DockPanel.Dock="Top" Name="mnuMenu">
      <MenuItem Header="_Datei">
        <MenuItem Command="ApplicationCommands.New" />
        <MenuItem Command="ApplicationCommands.Open">
          <MenuItem.Icon>
            <Image Source="Images/openHS.png" />
          </MenuItem.Icon>
        </MenuItem>
        <Separator />
        <MenuItem Command="ApplicationCommands.Save">
          <MenuItem.Icon>
            <Image Source="Images/saveHS.png" />
          </MenuItem.Icon>
        </MenuItem>
        <MenuItem Command="ApplicationCommands.SaveAs" />
        <Separator />
        <MenuItem Header="_Senden an">
          <MenuItem Header="_Mail" />
          <MenuItem Header="_Desktop" />
        </MenuItem>
        <MenuItem Header="_Beenden" />
      </MenuItem>
      <MenuItem Header="_Bearbeiten">
        <MenuItem Command="ApplicationCommands.Copy" />
        <MenuItem Command="ApplicationCommands.Cut" />
        <MenuItem Command="ApplicationCommands.Paste" />
      </MenuItem>    
    </Menu>
    <StackPanel>
      <TextBox Name="txtOben" Height="100"></TextBox>
      <TextBox Name="txtUnten" Height="100"></TextBox>
    </StackPanel>
  </DockPanel>
</Window>

Sie werden feststellen, dass die Menüpunkte nun nicht nur automatisch beschriftet werden, sondern dass darüber hinaus auch die allgemein üblichen Shortcuts eingeblendet werden.

Wenn Sie die Anwendung starten, funktioniert das Ausschneiden, Kopieren und Einfügen bereits einwandfrei. Wenn Sie Text in der oberen TextBox markieren und anschließend die untere fokussieren, können Sie den Text, der sich in der Zwischenablage befindet, in die untere TextBox einfügen. Kann eine Operation nicht ausgeführt werden, zum Beispiel weil sich keine Daten in der Zwischenablage befinden oder in der fokussierten TextBox keine Zeichen markiert sind, werden die entsprechenden Menüpunkte deaktiviert – und das, obwohl Sie keine Zeile Code geschrieben haben.


Galileo Computing - Zum Seitenanfang

20.5.3 Commando-Ziel festlegen Zur nächsten ÜberschriftZur vorigen Überschrift

Per Vorgabe ist das Ziel eines Kommandos das in dem Moment aktive Steuerelement. Bei Bedarf können Sie aber auch ein anderes Ziel festlegen. Neben dem Command-Attribut muss dann auch noch das Attribut CommandTarget angegeben werden. Dabei muss wieder die Binding-Syntax verwendet werden, wie das folgende Beispiel zeigt:


...
<MenuItem Header="_Bearbeiten">
  <MenuItem Command="ApplicationCommands.Copy"/>
  <MenuItem Command="ApplicationCommands.Cut" />
  <MenuItem Command="ApplicationCommands.Paste"  
            CommandTarget="{Binding ElementName=txtUnten}" />
</MenuItem>    
...


Galileo Computing - Zum Seitenanfang

20.5.4 Commands an Ereignisse binden Zur nächsten ÜberschriftZur vorigen Überschrift

Vielleicht ist Ihnen im Beispiel aufgefallen, dass die Untermenüpunkte von Datei alle deaktiviert sind. Das liegt daran, dass sich hinter den Kommandos kein Code verbirgt. Das ist auch nicht verwunderlich, denn es gibt keinen allgemeingültigen Code, der alle Umstände einer öffnenden Operation abdeckt, wie es beispielsweise beim Kopieren der Fall ist.

Hier hilft nur die Bindung eines Commands an einen Ereignishandler. Dabei kommt ein Objekt vom Typ CommandBinding ins Spiel, das mit Executed und CanExecute zwei Ereignisse bereitstellt. Executed führt die gewünschte Operation aus, und mit CanExecute wird optionalerweise geprüft, ob bestimmte Bedingungen erfüllt sind, damit der Befehl ausgeführt werden kann. Dazu stellt der zweite Parameter im Ereignishandler, der vom Typ CanExecuteRoutedEventArgs ist, mit CanExecute eine Eigenschaft bereit, der entweder true oder false übergeben werden muss. Mit CanExecute=false wird das Kommando deaktiviert.

Ein CommandBinding-Objekt muss mit einem Command verbunden werden. Dazu dient die gleichnamige Eigenschaft Command. Mit dem Attribut Excecuted oder CanExecute wird der Ereignishandler festgelegt, der auf das Kommando reagieren soll. Üblicherweise werden alle CommandBinding-Objekte im Bereich von Window angegeben.

Mit diesen Kenntnissen wollen wir die Anwendung so ergänzen, dass das komplette Menü mit Kommandos ausgestattet ist. Dabei sollen die Menüpunkte Speichern und Speichern als nur dann aktiviert werden, wenn die obere der beiden Textboxen nicht leer ist.


// ---------------------------------------------------------
// Beispiel: ...\Kapitel 20\ApplicationCommands
// ---------------------------------------------------------
<Window ...>
  <Window.CommandBindings>
    <CommandBinding Command="ApplicationCommands.New" 
                    Executed="New_Executed" />
   <CommandBinding Command="ApplicationCommands.Open" 
                   Executed="Open_Executed" />
   <CommandBinding Command="ApplicationCommands.Save" 
                   Executed="Save_Executed" 
                   CanExecute="Save_CanExecute"/>
   <CommandBinding Command="ApplicationCommands.SaveAs" 
                   Executed="SaveAs_Executed" 
                   CanExecute="Save_CanExecute" />
  </Window.CommandBindings>
  <DockPanel>
  ...
</Window>

In der Code-Behind-Datei wird der erforderliche Code für die Operationen hinterlegt. Allerdings enthält er in unserem Beispiel nur die Anzeige von Nachrichtenfenstern. Im Ernstfall müssen Sie hier natürlich die gewünschte Logik hinterlegen.


public partial class Window1 : Window {
  public Window1() {
    InitializeComponent()
  }
  private void New_Executed(object sender, ExecutedRoutedEventArgs e) {
    MessageBox.Show("Menüpunkt 'Neu'");
  }
  private void Open_Executed(object sender, ExecutedRoutedEventArgs e) {
    MessageBox.Show("Menüpunkt 'Öffnen'");
  }
  private void Save_Executed(object sender, ExecutedRoutedEventArgs e) {
    MessageBox.Show("Menüpunkt 'Speichern'");
  }
  private void SaveAs_Executed(object sender, ExecutedRoutedEventArgs e) {
    MessageBox.Show("Menüpunkt 'Speichern als'");
  }
  private void Save_CanExecute(object sender, CanExecuteRoutedEventArgs e) {
    if (txtOben.Text == "")
      e.CanExecute = false;
    else
      e.CanExecute = true;
  }
}


Galileo Computing - Zum Seitenanfang

20.5.5 Commands programmieren topZur vorigen Überschrift

Commands können auch per Code bereitgestellt werden. Der entsprechende Ereignishandler wird mit der bekannten Notation an das Ereignis gebunden:


public Window1() {
  InitializeComponent();
  CommandBinding cmdSave = new CommandBinding(ApplicationCommands.Save);
  cmdSave.Executed += 
         new ExecutedRoutedEventHandler(cmdSave_Executed);
}
void cmdSave_Executed(object sender, ExecutedRoutedEventArgs e) {
  // ...
}

Sie können auch die Execute-Methode eines Commands aufrufen, um das Ereignis auszulösen. Execute definiert zwei Parameter. Der erste erwartet ein benutzerdefiniertes Objekt, der zweite erwartet die Angabe des Ziels des Kommandos:


private void button1_Click(object sender, RoutedEventArgs e) {
  ApplicationCommands.Save.Execute(null, txtOben);
} 

Hier wäre das Kommandoziel demnach eine Komponente namens txtOben.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück
  Zum Katalog
Zum Katalog: Visual C# 2010

Visual C# 2010
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Katalog: Professionell entwickeln mit Visual C# 2012






 Professionell
 entwickeln mit
 Visual C# 2012


Zum Katalog: Windows Presentation Foundation






 Windows Presentation
 Foundation


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: C++ Handbuch






 C++ Handbuch


Zum Katalog: C/C++






 C/C++


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 2010
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


Nutzungsbestimmungen | Datenschutz | Impressum

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de

Cookie-Einstellungen ändern