![\"Neues](\"..\/fileadmin\/_temp_\/2015_01\/pic_8_001.png\")
<\/p>\nUnter Access war alles so einfach und gewohnt. Das Access-Fenster bildete den Rahmen, zeigt das Ribbon an oder stellte die Formulare und Berichte in Anwendungen dar. Für das Öffnen der Objekte brauchte man nur die DoCmd.Open…-Anweisung zu kennen. Unter .NET sieht das ganz anders aus: Das Anwendungsfenster ist bereits ein Formular, es gibt andere Steuerelemente – und das Öffnen von Formularen erfolgt auch ganz anders.<\/b><\/p>\n
Wenn Sie eine WPF-Anwendung erstellen (in diesem Beispiel für Programmiersprache C#), wählen Sie nach dem Starten von Visual Studio (hier in der Community-Edition der Version 2013) den Menüeintrag Datei|Neu|Projekt… <\/b>aus. Danach erscheint der Dialog Neues Projekt<\/b>, wo Sie unter Vorlagen|Visual C#|Windows-Desktop <\/b>die Vorlage WPF-Anwendung <\/b>selektieren (siehe Bild 1). Es gibt noch einige weitere Anwendungstypen auf Basis von WPF, aber wir konzentrieren uns hier zunächst auf die Desktop-Anwendung.<\/p>\n
<\/p>\n
Bild 1: Neues WPF-Projekt für Visual C# erstellen<\/span><\/b><\/p>\n Visual Studio bietet hier direkt ein Verzeichnis an, in dem das Projekt standardmäßig angelegt wird. Diesen können Sie natürlich ändern. Wichtig ist zu wissen, dass im angegebenen Verzeichnis ein Unterverzeichnis mit dem Namen des Projekts angelegt wird, das schließlich die eigentlichen Projektdateien enthält. In diesem Fall soll das Projekt VonAccessZuWPF <\/b>heißen.<\/p>\n Das Hauptfenster<\/b><\/p>\n Im Vergleich zu Access, wo das Access-Fenster das Hauptfenster der Anwendung ist (wenn Sie es nicht mit Tricks ausgeblendet haben), definieren Sie das Hauptfenster Ihrer WPF-Anwendung komplett neu. Dazu bietet Visual Studio im neuen Projekt standardmäßig ein Fenster namens MainWindow <\/b>hinzu. Wir wollen uns an dieser Stelle daraufhin einigen, statt wie in Access von Formularen künftig von Fenstern zu sprechen.<\/p>\n Das Formular wird mithilfe von zwei Dateien beschrieben:<\/p>\n Die .xaml<\/b>-Datei stellt Visual Studio in einem Bereich dar, der oben den Entwurf des Fensters anzeigt und unten den XML-Code, der das Aussehen definiert. Sie können das Aussehen auf folgenden Wegen beeinflussen:<\/p>\n Jegliche Änderungen an diesen drei Stellen wirken sich direkt auf die jeweils anderen Wege aus. Wenn Sie also im XML-Code die Breite des Window<\/b>-Elements mit dem Attribut Width <\/b>auf 600<\/b> einstellen, wird das Fenster direkt in dieser Breite dargestellt und auch der entsprechende Eintrag im Eigenschaftsfenster wird geändert.<\/p>\n Beispielprojekt: <\/b>Den Code für die Beispiele der folgenden Abschnitte finden Sie in einem neuen, jungfräulichen WPF-Projekt.<\/p>\n Code des Hauptfensters<\/b><\/p>\n Die Datei MainWindow.xaml <\/b>enthält den folgenden Code:<\/p>\n Hier finden Sie die beim Start vorhandenen Einstellungen: Der Titel lautet MainWindow<\/b>, außerdem sind Höhe und Breite auf 350 <\/b>und 600 <\/b>festgelegt. Eine weitere wichtige Information finden Sie gleich in der ersten Zeile: Unter x:Class <\/b>gibt das Dokument die C#-Datei an, die den Code für dieses Fenster enthält – in diesem Fall VonAccessZuWPF.MainWindow<\/b>. Alle Elemente, die Sie nun zum Fenster hinzufügen, landen als Beschreibung innerhalb des Grid<\/b>-Elements ( XAML und C#<\/b><\/p>\n Damit wird nun offensichtlich: Es gibt zwei verschiedene Dateien zur Programmierung eines Fensters unter WPF – die XML-Datei mit der XAML-Definition der Benutzeroberfläche und eine C#-Datei mit den Funktionen des Fensters. Im Vergleich mit einem Access-Formular entspricht die Entwurfsansicht des WPF-Fensters dem Formularentwurf und die C#-Datei mit dem Code dem Klassenmodul des Formulars.<\/p>\n Unter Access werden intern allerdings sowohl die Beschreibung des Formulars sowie der Steuerelemente als auch der VBA-Code in einem einzigen Dokument untergebracht, was auch deutlich wird, wenn Sie dieses vom VBA-Fenster etwa mit der SaveAsText<\/b>-Anweisung in eine Textdatei exportieren und in einem Texteditor ansehen. Das “Klassenmodul” mit dem C#-Code hinter dem Fenster MainWindow <\/b>hat den folgenden Inhalt:<\/p>\n Hier geschieht noch nichts Spektakuläres, da wir noch keine Ereignisprozeduren et cetera angelegt haben. Die einzige Methode namens InitializeComponent<\/b> erstellt kurz gefasst das Fenster auf Basis der XAML-Datei.<\/p>\n Wenn Sie genau wissen wollen, welcher Code sich hinter einer Anweisung befindet, klicken Sie ähnlich wie im VBA-Editor mit der rechten Maustaste und wählen den Eintrag Definition einsehen <\/b>aus. Es erscheint dann ein gelb hinterlegter Bereich mit der Routine, die durch die Anweisung ausgelöst wird (siehe Bild 2).<\/p>\n Bild 2: Der Code hinter einer Anweisung wird farbig hinterlegt eingeblendet.<\/span><\/b><\/p>\n Trennung von Oberfläche und Code<\/b><\/p>\n Die Definition der Benutzeroberfläche und der Code sind nicht nur dateiweise getrennt, sondern sie können auch komplett unabhängig voneinander bearbeitet werden. Während es unter Access kaum möglich ist, dass ein Entwickler Änderungen an der Benutzeroberfläche vornimmt, während ein anderer den Programmcode anpasst, gibt es für WPF mit Blend für Visual Studio <\/b>sogar ein eigenes Werkzeug für die Verfeinerung der Benutzeroberfläche.<\/p>\n Vorteil Visual Studio: Zoom<\/b><\/p>\n Wenn Sie Ihr erstes Fenster erstellen, können Sie direkt ein Feature ausprobieren, das dem Access-Entwickler wohl für immer vorbehalten bleibt: Sie können die Ansicht des Entwurfs vergrößern oder verkleinern. Dazu sollten Sie sich gleich die folgenden Tastenkombinationen merken:<\/p>\n Steuerelemente hinzufügen<\/b><\/p>\n Standardmäßig im linken Bereich von Visual Studio finden Sie den Werkzeugkasten. Dieser bietet verschiedene Sammlungen von Steuerelementen. Die obere liefert mit Häufig verwendete WPF-Steuerelemente <\/b>die gängigen Steuerelemente, die Sie auch von Access her kennen – aber auch einige neue Kandidaten. Unter Alle WPF-Steuerelemente <\/b>finden Sie die komplette Sammlung. Fügen Sie hier wie in Bild 3 eine Schaltfläche zum WPF-Fenster hinzu. Sie erkennen direkt, dass nicht nur die Schaltfläche im Fenster erscheint, sondern auch, dass der Designer ein Element zur XAML-Datei des Fensters hinzugefügt hat, und zwar in das Grid<\/b>-Element:<\/p>\n Bild 3: Neues Steuerelement im Entwurf und im XAML-Code<\/span><\/b><\/p>\n Dazu erhält das Steuerelement direkt einige Werte für Standardeigenschaften wie die horizontale und vertikale Ausrichtung (HorizontalAlignment <\/b>und VerticalAlignment<\/b>), die Ränder (Margin<\/b>) und die Breite (Width<\/b>). Die Beschriftung landet im Attribut Content<\/b>. Klicken Sie nun auf F5<\/b>, starten Sie die WPF-Anwendung und das Fenster mit der Schaltfläche erscheint – diese ist allerdings noch ohne Funktion (siehe Bild 4).<\/p>\n Bild 4: Erster Test des neuen Fensters<\/span><\/b><\/p>\n Startfenster ändern<\/b><\/p>\n In einer Access-Anwendung ist standardmäßig kein Formular als Startformular der Anwendung voreingestellt. Das ist kein Problem: Sie können ja dort beispielsweise ein benutzerdefiniertes Ribbon anzeigen, mit dem der Benutzer die gewünschten Elemente der Benutzeroberfläche öffnen kann. Alternativ wählen Sie für die Eigenschaft Startformular <\/b>der Access-Optionen das beim Starten der Anwendung anzuzeigende Formular an. Bei einer WPF-Anwendung müssen Sie zwingend ein Startfenster angeben, denn sonst würde beim Start ja überhaupt keine Benutzeroberfläche erscheinen. Aus diesem Grund enthält ein neues WPF-Projekt ja auch gleich nach dem Start ein solches Fenster.<\/p>\n Wie aber gehen Sie vor, wenn Sie beispielsweise ein anderes Fenster beim Start der Anwendung anzeigen möchten Dazu müssen Sie einfach nur den Inhalt der Datei App.xaml <\/b>ändern. Dort gibt es im Application<\/b>-Element ein Attribut namens StartupUri<\/b>, das standardmäßig den Wert MainWindow.xaml <\/b>enthält. Geben Sie hier einfach den Namen des beim Start anzuzeigenden Fensters ein (siehe Bild 5). Auch zu App.xaml <\/b>gibt es eine entsprechende C#-Datei namens App.xaml.cs<\/b>. Die App.xaml<\/b>-Datei ist wichtig, weil sie der Startpunkt der Anwendung ist und, wie oben bereits beschrieben, den Namen des anzuzeigenden Fensters enthält.<\/p>\n Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>\n
\n
<Window x:Class=\"VonAccessZuWPF.MainWindow\"\r\n xmlns=\"http:\/\/schemas.microsoft.com\/winfx\/2006\/ xaml\/presentation\"\r\n xmlns:x=\"http:\/\/schemas.microsoft.com\/winfx\/2006\/xaml\"\r\n Title=\"MainWindow\" Height=\"350\" Width=\"600\">\r\n <Grid>\r\n <\/Grid>\r\n<\/Window><\/pre>\n
namespace VonAccessZuWPF\r\n{\r\n \/\/\/ <summary>\r\n \/\/\/ Interaktionslogik für MainWindow.xaml\r\n \/\/\/ <\/summary>\r\n public partial class MainWindow : Window\r\n {\r\n public MainWindow()\r\n {\r\n InitializeComponent();\r\n }\r\n }\r\n}<\/pre>\n![\"Der](\"..\/fileadmin\/_temp_\/2015_01\/pic_8_004.png\")
<\/p>\n\n
![\"Neues](\"..\/fileadmin\/_temp_\/2015_01\/pic_8_003.png\")
<\/p>\n<Button Content=\"Button\" HorizontalAlignment=\"Left\" \r\nMargin=\"36,34,0,0\" VerticalAlignment=\"Top\" Width=\"75\"\/><\/pre>\n
![\"Erster](\"..\/fileadmin\/_temp_\/2015_01\/pic_8_005.png\")
<\/p>\n![\"Angabe](\"..\/fileadmin\/_temp_\/2015_01\/pic_8_002.png\")
<\/p>\n
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t