Startseite  Inhaltsverzeichnis  <<  >>  

Kapitel 2 - Grundlagen

2.1 Projekttypen

Das Übersetzen von Anwendungen auf der Konsole erfordert den Aufruf des Menüpunkt START - PROGRAMME - MICROSOFT WINFX SDK - OPEN BUILD ENVIRONMENT WINDOW - WINFX BUILD ENVIRONMENT, das Wechseln in das entsprechende Verzeichnis und den folgenden Aufruf des C#-Kompilers.

csc /r:c:\windows\Microsoft.net\Windows\v6.0.4030\PresentationCore.dll
    /r:c:\windows\Microsoft.net\Windows\v6.0.4030\PresentationFramework.dll
    /r:c:\windows\Microsoft.net\Windows\v6.0.4030\WindowsBase.dll
    MainApp.cs

2.2 Dateitypen

2.3 Einfache Anwendungen

Das Avalon-Framework basiert auf verschiedenen Namespaces, die in einer älteren Version noch mit MSAvalon begonnen haben. Nun wurden die Namen in System.xxx geändert.

System.Windows.ControlsUI-Kontrollelemente
System.Windows.DocumentsAvalon Document-Service-Klassen
System.Windows.ShapesGrafik-primitive
System.Windows.Media2D- und 3D-Grafik
System.Windows.NavigationNavigationsklassen
System.Windows.DataDatenanbindung an Eigenschaften
System.WindowsFensterbasisklassen, Application, XAML-Unterstützung, Ereignisunterst.
System.Windows.Controls.PrimitivesKlassen die als Basiselemente in komplexen Kontrollelementen verwendet werden.
System.Windows.Media.AnimationAnimationsklassen
System.Windows.Media.Media3D3D-Grafik
System.Windows.AnnotationsAnmerkungsklassen für Dokumente

Die Klasse System.Windows.Application ist der Einsprungpunkt für eine Standardanwendung. Im einfachsten Fall haben Sie dann nur eine *.cs-Datei die ein Application-Objekt erzeugt und dessen Methode Run() aufruft. Die Erstellung des Hauptfensters der Anwendung erfolgt im Ereignis OnStartingUp. Der Einsprungpunkt einer Anwendung ist auch hier die Methode Main der Hauptklasse der Anwendung. Diese muss explizit mit dem Attribut System.STAThread versehen werden.

Eigenschaften:

Current Diese statische Eigenschaft fiefert das aktuelle (Navigation)Application-Object.
MainWindow Setzt oder liest das Hauptfenster der Anwendung (als Window-Objekt).
ShutdownMode Legt fest, wann eine Anwendung beendet wird
OnLastWindowClose - 0 - wenn letztes Fenster geschlossen wird oder die Anwendung explizit beendet wird - default
OnMainWindowClose - 1 - Beenden, wenn das Hauptfenster geschlossen wird oder Application.Shutdown aufgerufen wird
OnExplicitShutdown - 2 - Beenden, wenn explizit Application.Shutdown aufgerufen wird).
Windows Aufzählung aller Anwendungsfenster

Ereignisse:

OnStartingUp
OnShuttingDown		 Starten und Beenden der Anwendung 
using System;
using System.Windows;
using System.Windows.Controls;

namespace Beispiel3
{
    public class MainApp: Application
    {
        [System.STAThread]
        public static void Main()
        {
            MainApp ma = new MainApp();
            ma.Run();
        }

        protected override void OnStartingUp(StartingUpCancelEventArgs e)
        {
            base.OnStartingUp(e);
            Console.WriteLine("Starte");
            ShowMainWindow();
        }

        private void ShowMainWindow()
        {
            Window win = new Window();
            DockPanel dp = new DockPanel();
            TextBox tb = new TextBox();
            tb.Text = "Hallo";
            win.Content = dp;
            DockPanel.SetDock(tb, System.Windows.Controls.Dock.Top);
            dp.Children.Add(tb);
            win.Show();
        }
    }
}

2.4 XAML - Extensible Application Markup Language

XAML (sprich engl. "Zamel", dt. "Semmel") ist eine Markupsprache (ähnlich HTML) zur Beschreibung grafischer Oberflächen. Neben den Oberflächenelementen können Sie über XAML auch Code einfügen und mit den Elementen verknüpfen. Alles was Sie über XAML durchführen, ist auch direkt mit C# möglich. Der umgekehrte Fall gilt aber nicht, das heißt XAML ersetzt in keinen Fall C#. Weiterhin ist die Definition von Daten und deren Verwendung in den Oberflächenelementen erlaubt (Data Binding). Selbst komplexe Animationen können Sie mit XAML definieren. XAML wird in Zukunft sicher hauptsächlich durch visuelle Editoren generiert. Die manuelle Eingabe wird im Visual Studio aber natürlich auch durch den Editor durch IntelliSense unterstützt.

Vorteile von XAML

Aufbau einer XAML-Datei Grundsätzlich entspricht der Aufbau einem wohlgeformten XML-Dokument. Sie besitzt ein Wurzelelement, jedes Element besitzt einen schließenden Gegenpart und die Elemente können Attribute besitzen. Speziell in XAML entspricht jedes Element einem Klassennamen aus dem .NET-Framework. Die Definition eines XAML-Elements ist mit der Instanzierung eines Objekts dieser Klasse vergleichbar. Attribute eines Elements kennzeichnen Eigenschaften, Felder und Ereignisse des Objekts.

Beispiel Das Wurzelelement schließt im folgenden Beispiel alle weiteren Elemente ein. Weiterhin bindet es den Default-Namespace http://schemas.microsoft.com/2003/xaml, der bei allen unqualifizierten Elementen zugrunde gelegt wird. Das Element <Unterelement> müßte sich demnach in diesem Namespace befinden. Die Einbindung des Default-Namespaces bewirkt sozusagen die Einbindung sämtlicher benötigter using-Anweisungen, um die entsprechenden .NET-Klassen zu verwenden.
using System;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Shapes;
using System.Windows.Media;
using System.Windows.Navigation;
using System.Windows.Data;
using System.Windows;
using System.Windows.Controls.Primitives;
using System.Windows.Media.Animation;
using System.Windows.Media.Media3D;
using System.Windows.Annotations;
using System.Windows.Annotations.Anchoring;
using System.Windows.Annotations.Storage;
Desweiteren wird ein Namespace x definiert, der zur Kennzeichnung von Definitionen genutzt wird. Durch die weitere Verschachtelung von Elementen wird eine Oberlächenstruktur geschaffen. So kann in ein Fenster ein Panel und darauf eine Schaltfläche eingefügt werden. 
<Wurzelelement xmlns="http://schemas.microsoft.com/2003/xaml"
                  xmlns:x="Definition">
  <Unterelement>
  </Unterelement>
</Wurzelelement>
Um weitere .NET-Typen aus anderen, z.B. selbstdefinierten, Namespaces zuzulassen, müssen Sie diese über ein Mapping einbinden. Dazu dient die PI (Processing Instruction) ?Mapping. Im Beispiel wird dazu der Präfix meinName definiert, der sich im .NET-Namespace Mein.NameSpace befindet. Die Assembly wird über das gleichnamige Attribut angegeben. Um dann später die Klasse Element zu verwenden, wird der Präfix des Namespaces davor gesetzt, also meinName:Element. 
<?Mapping XmlNamespace="meinName" ClrNamespace="Mein.NameSpace" Assembly="MeineAssembly.dll" ?>
<Wurzelelement xmlns="http://schemas.microsoft.com/2003/xaml"
                  xmlns:x="Definition">
  <Unterelement>
    <meinName:Element />
  </Unterelement>
</Wurzelelement>
Beispiel Es wird zuerst ein einfaches Fenster mit einer Schaltfläche erzeugt. Die Schaltflächen werden anhand des Textes automatisch in der Größe angepaßt. Auch die Position wird automatisch festgelegt. Dies ist in diesem Fall übereinander. Für die Festlegung der Beschriftung werden vier Varianten verwendet.
  1. Innerhalb des Buttons wird über eine weitere Verschachtelung ein Text-Element eingefügt. Dieser Text erscheint dann innerhalb des Buttons als Beschriftung.
  2. In der zweiten Variante wird einfach der Text angegeben.
  3. Die dritte Lösung setzt den Wert der Eigenschaft Content, also den Inhalt des Buttons, der in diesem Fall wieder mit der Bechriftung übereinstimmt. Die Eigenschaft wird als Attribut im Element Button eingefügt.
  4. Eigenschaften können auch über eine sepezielle Syntax als untergeordnetes Element eingefügt werden. Dazu wird der Element-Name und der Eigenschaftsname mit einem Punkt voneinder getrennt als Elementname verwendet. 

<Window xmlns="http://schemas.microsoft.com/2003/xaml">
  <Button>
    <Text>Klick mich...1</Text>
  </Button>
  <Button>
    Klick mich...1
  </Button>
  <Button Content="Klick mich...1" />
  <Button>
    <Button.Content>Klick mich...3</Button.Content>
  </Button>
</Window>
Damit die Buttons einigermaßen ordentlich angeordnet werden, muss ein Layout verwendet werden (ja, wie in Java). Das FlowPanel ordnet z.B. die Elemente einfach hintereinander an. Reicht der Platz nicht, geht es darunter weiter.



Damit in einem C#-Projekt im Visual Studio die Verknüpfung der C#-Datei mit der XAML-Datei erfolgen kann, sind die Definitionen x:Class und xmlns:Definition notwendig. Die Attribute Text, Width und Height im <Window>-Element bewirken, dass das Fenster einen Titel erhält und eine Breite und Höhe vorgegeben wird. Die Buttons werden nun in ein FlowPanel-Element eingeschlossen, das für die Ausrichtung verantwortlich ist. 
<Window x:Class="Beispiel2.Window1"
        xmlns="http://schemas.microsoft.com/2003/xaml" xmlns:x="Definition"
        Text="Beispiel2" Width="300" Height="200">
  <FlowPanel>
    <Button>
      <Text>Klick mich...1</Text>
    </Button>
    <Button>
      Klick mich...1
    </Button>
    <Button Content="Klick mich...1" />
    <Button>
      <Button.Content>Klick mich...3</Button.Content>
    </Button>
  </FlowPanel>
</Window>
TIPP: Entfernen Sie im Element <Window> die Attribute x:Class und xmlns:Definition können Sie die *.xaml-Datei sogar direkt im Internet Explorer öffnen.

Der SourceCode zum Erstellen eines Buttons mit einer Beschriftung sehe übrigens ungefähr so aus.

  Button btn = new Button();
  btn.Content = "Klick mich...1";
Typumwandlungen

Die Werte der Attribute werden immer als Zeichenketten angegeben. Wird eine ganze Zahl oder Gleitkommazahl benötigt, muss die korrekte Schreibweise verwendet werden. Intern werden dann die benötigten Typkonvertierungen vorgenommen.

Ein paar weitere Eigenschaften

Es wird ein Button mit der Schriftgröße 18 Pixel, der Farbe hellblau, mit der Schriftart Verdana, kursiv und einer Transparent von 0.5 erzeugt. Die Eigenschaft Content ist nicht wie es vermuten lässt vom Typ string sondern Object. Dies erlaubt es, auch komplexe Objekte wie z.B. ein Bild als Beschriftung des Buttons zu verwenden. 
<Button Content="Klick mich...1" FontSize="18px" Background="LightBlue" FontFamily="Verdana" FontStyle="Italic" Opacity=".5" />
<Button FontSize="18px" Background="LightBlue" FontFamily="Verdana" FontStyle="Italic" Opacity=".5">
  <Image Source="Bild.jpg" Width="100" Height="300" />
</Button>
Auch Bilder mit Text erlaubt XAML. Allerdings müssen Sie nun beide wieder in ein neues Element einschließen. 
<Button FontSize="18px" Background="LightBlue" FontFamily="Verdana" FontStyle="Italic" Opacity=".5">
  <Text>
    <Image Source="Delphi1KK.jpg" Width="100" Height="300" />
    Bla Bla
  </Text>
</Button>