Windows-Anwendungen mit PowerShell und Windows Presentation Framework (WPF) – Teil 2

Die PowerShell bietet uns heute vielfältige Möglichkeiten bei der Automatisierung von Abläufen unter Windows. Im PowerShell-Kommandozeilen-Fenster lassen sich einfache Befehle oder komplexe Skripte ausführen. Doch als Nachteil der PowerShell sehen viele, dass keine CmdLets existieren, um eigene Oberflächen zu gestalten. Deshalb geben sie die Ausgabewerte einfach in dem PowerShell-Kommandozeilen-Fenster aus. Das wird jedoch schnell unübersichtlich und ist für eine weitere Verarbeitung kaum geeignet.

Mit dieser Artikelserie möchte ich Ihnen die Vorgehensweise zur Erstellung von ansprechenden Windows-Anwendungen mit PowerShell und WPF aufzeigen.

Artikel der Serie

Die Artikelserie wendet sich an alle die Interesse an dem Thema PowerShell und damit bereits ein wenig rumexperimentiert haben. Da ich jeden Schritt in der Anleitung erklären werde, sollte Sie dies schnell und einfach auf Ihre eigene Aufgabenstellung adaptieren können.

Steuerelemente

Nachdem wir uns im ersten Teil dieser Serie mit den Grundlagen beschäftigt haben, möchte ich mich im diesem Teil der Serie damit beschäftigen, wie Sie das bisher noch leere Windows-Anwendungsfenster etwas verschönern und mit Leben füllen können. Dazu werden ich Ihnen zeigen, wie Sie verschiedenen Steuerelemente verwenden, Es geht mir hierbei jedoch im ersten Schritt um die Darstellung der Elemente auf Basis der XAML-Struktur.

Für die geplante Anwendung benötigen wir nur wenige verschiedenen Steuerelemente:

  • Label 
  • Grid
  • Menu
  • ScrollViewer
  • Dockpanel 
  • DataGrid

Das Windows Presentation Framework bietet zwar standardmäßig noch viele andere Arten von Steuerelemente. Ziel dieses Artikels soll es nicht sein, die verschiedenen Steuerelemente bis ins Detail zu beschreiben, sondern er soll zeigen, wie Sie diese Controls innerhalb der Anwendung verwenden können – und Ihnen möglicherweise den einen oder anderen Trick zeigen. Sollten Sie zu diesen oder zu anderen Steuerelementen noch weitere Informationen benötigen, kann ich Ihnen die folgende Web-Seite empfehlen.

In den folgenden Beispielen arbeite ich auch mit verschiedenen Eigenschaften der Steuerelemente. Die Steuerelemente und dazugehörenden Eigenschaften werde ich im diesem Artikel der Serie noch fest in die XAML-Struktur einbauen. In einem späteren Artikel werde ich dann darauf eingehen, wie Sie Steuerelemente dynamisch erzeugen/löschen und Eigenschaften mit Hilfe der PowerShell setzen und ändern können.

Die Schreibweise der Tag-Namen und der Eigenschaften ist genauso festgelegt, wie ich diese in dem Artikel verwendet habe – im Unterschied zu PowerShell spielt hier Groß-/Kleinschreibung eine Rolle.

Label

Dazu fangen wir ganz einfach an und fügen in unser Fenster (dessen Sourcecode sie aus dem vorangegangenen Artikel verwenden können) einen Text ein. Dazu verwende ich ein Label-Steuerelement. Um ein solches Element in das Programm einzufügen, brauchen Sie nur das entsprechende Label-Tag der XAML-Struktur hinzuzufügen und dem Label einen Text zuzuweisen. Ansonsten sind keine weiteren Änderungen am Sourcecode erforderlich.

[xml]$xaml = @" 
    <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"&
        Title="Test-Anwendung" Height="200" Width="200">
        <Label>Hello World!</Label> 
    </Window>
"@ 
Add-Type -Assembly PresentationFramework 
$reader=(New-Object System.Xml.XmlNodeReader $xaml)
$Form=[Windows.Markup.XamlReader]::Load( $reader ) 
$c = $Form.ShowDialog()

image

Mit einem einzelnen Label-Steuerelement erreicht man, dass das gesamte Windows-Fenster den Inhalt dieses Labels als Content übernimmt.

Grid

Versucht man nun ein zweites Label in das Fenster zu positionieren, erhält man eine Fehlermeldung. Um das Problem zu umgehen, benötigt man einen Container, in dem Sie mehrere Steuerelemente positionieren können. Ein solches Container-Steuerelement ist beispielsweise ein Grid. Neben diesem Containertyp gibt es jedoch noch eine Reihe weiterer solcher Typen. Eine Auflistung dieser finden Sie unter Übersicht über Panel-Elemente.

Für diese Aufgabe ist das Grid-Steuerelement jedoch bereits gut geeignet, da man damit einen flexiblen Rasterbereich, der aus Spalten und Zeilen besteht, definieren kann.  Untergeordnete Elemente eines Grid-Elements können mit der Margin-Eigenschaft genau positioniert werden.

Im der folgenden XAML-Struktur habe ich ein Grid mit zwei Labels eingefügt.

<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Test-Anwendung" Height="200" Width="200">
    <Grid>
        <Label>Label 1</Label>
        <Label Margin="0,20">Label 2</Label>
    </Grid> 
</Window>

Damit die beiden Labels nicht übereinander positioniert werden, muss eine Position innerhalb des Grid-Containers definiert werden. Dazu kann man die Eigenschaft Margin verwenden. Mit dieser Eigenschaft wird der Rand zum umgebenden Container festgelegt. Die Margin-Eigenschaft beinhaltet bis zu 4 einzelnen Werten, die durch Komma voneinander getrennt sind (Margin=“left,top,right,bottom“).

Wenn Sie die XAML-Struktur in dem PowerShell-Skript ersetzen, sieht dann das Ergebnis  folgendermaßen aus:

image

Wie Sie bereits festgestellt haben, handelt es sich bei der XAML-Struktur in PowerShell um eine Zeichenkette, die Sie mit String-Manipulation entsprechend anpassen können. Um die Inhalte der Label-Steuerelemente dynamisch beim Starten der Anwendung zu setzen, können Sie dies direkt in der Zeichenkette vornehmen, indem Sie an die entsprechende Position eine PowerShell-Variable einfügen.

<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Test-Anwendung" Height="200" Width="200">
    <Grid>
        <Label>Computer name:</Label>
        <Label Margin="0,20">$($env:COMPUTERNAME)</Label>
    </Grid> 
</Window>

In folgenden Schritt möchte ich dem Fenster ein Menü zuweisen. Das könnten Sie direkt vornehmen, jedoch würden sich dadurch die Positionen (Margin) der Steuerelemente möglicherweise überlappen, die wir bereits eingefügt haben. Einfacher wird es, wenn Sie das Grid in zwei feste Bereiche unterteilen – einen für das Menü und einen für den Inhalt. Dafür definieren wir einen Bereich mit der Höhe von 25 Pixel und einen zweiten Bereich mit der restlichen Fensterhöhe:

<Window xmlns=“http://schemas.microsoft.com/winfx/2006/xaml/presentation“
    xmlns:x=“http://schemas.microsoft.com/winfx/2006/xaml“
    Title=“Test-Anwendung“ Height=“200″ Width=“200″>
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height=“25″ />
            <RowDefinition Height=“*“ />
        </Grid.RowDefinitions>
        <Label Grid.Row=“0″>Computer name:</Label>
        <Label Grid.Row=“1″>$($env:COMPUTERNAME)</Label>
    </Grid>
</Window>

Damit nun jedes Steuerelement weiß, in welchem Bereich des Grids es sich befinden wird, müssen Sie die jeweilige Bereichsnummer mit angeben (Grid.Row=”<Bereichsnummer>”).

image

Menü

Zum Einfügen des Menüs in die Oberfläche habe ich im vorhergehenden Schritt bereits einen Bereich reserviert. Dadurch wird es nun einfacher das Menü der Anwendung hinzuzufügen. Das Menü soll dabei folgenden Aufbau haben:

File Options Help
  Open     About
  Close    
  Print    
  Export    
  Exit    

Zu den Inhalten des Menüs werde ich, soweit diese nicht selbsterklärend sind, im nächsten Teil genauer darauf eingehen.

Zum Einfügen eines Menüs in eine WPF-Windowsanwendung fügen Sie nur einen entsprechenden Menu-Tag ein. Innerhalb dieses Menu-Tags können Sie dann entsprechend Ihren Anforderungen MenuItem-Tags einfügen. Benötigen Sie zu diesen MenuItems noch Untermenüs, so verschachteln Sie die MenuItems einfach ineinander. Möchten Sie die einzelnen MenuItems über eine ALT-Tastenkombination ansprechen, so können Sie einen Unterstrich (“_”) vor dem entsprechenden Buchstaben einfügen (z. B. “_Open” = ALT+O). Zusätzlich lässt sich noch eine alternative Tastenkombination über die Eigenschaft “InputGestureText” festlegen. Sollen MenuItems voneinander getrennt werden, kann ein Separator-Tag eingefügt werden.

<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"   
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"   
    Title="Test-Anwendung" Height="200" Width="200">   
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>
        <Menu Height="22" Name="menu1" VerticalAlignment="Top" Grid.Row="0">
            <MenuItem Header="_File" Name="File">
            <MenuItem Header="_Open" Name="Open" InputGestureText="Ctrl+O" />
            <MenuItem Header="_Close" Name="Close" InputGestureText="Ctrl+T" />
            <MenuItem Header="_Print" Name="Print" InputGestureText="Ctrl+P" />
            <MenuItem Header="E_xport" Name="Export" InputGestureText="Ctrl+X" />
            <Separator/>
            <MenuItem Header="_Exit" Name="Exit" InputGestureText="ALT+F4" />
            </MenuItem>
            <MenuItem Header="_Options" Name="Options" />
            <MenuItem Header="_Help" Name="Help" />
        </Menu>
    </Grid>
</Window>

image

Die Verwendung des Menüs und deren Eigenschaften in einer WPF-Anwendung sind meiner Meinung nach selbsterklärend. An dieser Stelle ist es jedoch wichtig zu wissen, dass die MenuItems noch keine Ereignisse auslösen, wenn Sie diese anklicken. Damit etwas passiert, muss jedem MenuItem noch eine Funktion (Ereignis) zugewiesen werden. Da wir dies mit der PowerShell implementieren müssen, werde ich im nächsten Teil dieser Artikelserie darauf eingehen.

Hinweis: Bei der Verwendung von Visual Studio zum Bearbeiten der XAML-Struktur steht Ihnen ein Assistent zum Erstellen des Menüs zur Verfügung.

image

ScrollViewer

Mit dem ScrollViewer-Control erstellen Sie einen Bereich in Ihrer Anwendung, in dem Scroll-Balken (Bildlauf) angezeigt werden. Dies ist dann sinnvoll, wenn Sie in einem Bereich mehr Inhalt haben, als in dem Bereich der Anwendung dargestellt werden kann.

<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"   
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"   
    Title="Test-Anwendung" Height="200" Width="200">   
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>
        <Menu Height="22" Name="menu1" VerticalAlignment="Top" Grid.Row="0">
            <MenuItem Header="_File" Name="File">
            <MenuItem Header="_Open" Name="Open" InputGestureText="Ctrl+O" />
            <MenuItem Header="_Close" Name="Close" InputGestureText="Ctrl+T" />
            <MenuItem Header="_Print" Name="Print" InputGestureText="Ctrl+P" />
            <MenuItem Header="E_xport" Name="Export" InputGestureText="Ctrl+X" />
            <Separator/>
            <MenuItem Header="_Exit" Name="Exit" InputGestureText="ALT+F4" />
            </MenuItem>
            <MenuItem Header="_Options" Name="Options" />
            <MenuItem Header="_Help" Name="Help" />
        </Menu>
        <ScrollViewer Grid.Row="1">
        </ScrollViewer>
    </Grid>
</Window>

image

Das ScrollViewer-Control verfügt ebenfalls über mehrere Eigenschaften. Diese benötigen wir für diese Anwendung jedoch nicht. Als einzige Definition setze ich nur einen Verweis, in welchem Bereich der ScrollViewer aktiv werden soll (Grid.Row=”1”).

Dockpanel

Damit wir innerhalb des Scrollbereichs weitere Steuerelemente aufnehmen können, benötigen wir erneut ein Container-Steuerelement. Für diesen Zweck eignet sich das DockPanel, da man in diesem  Bereich untergeordnete Elemente horizontal oder vertikal relativ zueinander anordnen kann.

Zusätzlich habe ich den Hintergrund des Steuerelements farblich hervorgehoben und eine Bindung an das ScrollViewer-Control eingefügt.

<Window xmlns=“http://schemas.microsoft.com/winfx/2006/xaml/presentation&#8220; xmlns:x=“http://schemas.microsoft.com/winfx/2006/xaml&#8220; Title=“Test-Anwendung“ Height=“200″ Width=“200″> <Grid> <Grid.RowDefinitions> <RowDefinition Height=“Auto“ /> <RowDefinition Height=“*“ /> </Grid.RowDefinitions> <Menu Height=“22″ Name=“menu1″ VerticalAlignment=“Top“ Grid.Row=“0″> <MenuItem Header=“_File“ Name=“File“> <MenuItem Header=“_Open“ Name=“Open“ InputGestureText=“Ctrl+O“ /> <MenuItem Header=“_Close“ Name=“Close“ InputGestureText=“Ctrl+T“ /> <MenuItem Header=“_Print“ Name=“Print“ InputGestureText=“Ctrl+P“ /> <MenuItem Header=“E_xport“ Name=“Export“ InputGestureText=“Ctrl+X“ /> <Separator/> <MenuItem Header=“_Exit“ Name=“Exit“ InputGestureText=“ALT+F4″ /> </MenuItem> <MenuItem Header=“_Options“ Name=“Options“ /> <MenuItem Header=“_Help“ Name=“Help“ /> </Menu> <ScrollViewer Grid.Row=“1″> <DockPanel Name=“DP“ Background=“LightBlue“ ScrollViewer.CanContentScroll=“True“ ScrollViewer.HorizontalScrollBarVisibility=“visible“ ScrollViewer.VerticalScrollBarVisibility=“visible“ /> </ScrollViewer> </Grid> </Window>

Hinweis: Eine farbliche Hinterlegung bestimmter Bereiche erleichtert die genaue Positionierung von Elementen.

Sollte also irgendwann einmal etwas komisch aussehen, einfach das Attribut “Background” und einen bestimmten Farbwert einfügen. Danach wird es oft klarer. 

Das DockPanel in der Abbildung erkennen Sie nun an dem hellblauen Hintergrund. Ansonsten hat sich an der Anwendung nur wenig geändert.

image

DataGrid

Als letztes Steuerelement für unsere Anwendung benötigen wir das DataGrid. Dabei handelt es sich Steuerelement mit Datenbindung, mit dem Sie Daten aus zahlreichen verschiedenen Quellen, z. B. aus einer SQL-Datenbank, einer LINQ-Abfrage oder einer anderen bindungsfähigen Datenquelle, anzuzeigen und zu bearbeiten. Somit ist dieses Steuerelement ideal dafür geeignet, Ergebnisdaten aus Resultsets von SQL Server Abfragen darzustellen.

 

<Window xmlns=“http://schemas.microsoft.com/winfx/2006/xaml/presentation&#8220; xmlns:x=“http://schemas.microsoft.com/winfx/2006/xaml&#8220; Title=“Test-Anwendung“ Height=“200″ Width=“200″> <Grid> <Grid.RowDefinitions> <RowDefinition Height=“Auto“ /> <RowDefinition Height=“*“ /> </Grid.RowDefinitions> <Menu Height=“22″ Name=“menu1″ VerticalAlignment=“Top“ Grid.Row=“0″> <MenuItem Header=“_File“ Name=“File“> <MenuItem Header=“_Open“ Name=“Open“ InputGestureText=“Ctrl+O“ /> <MenuItem Header=“_Close“ Name=“Close“ InputGestureText=“Ctrl+T“ /> <MenuItem Header=“_Print“ Name=“Print“ InputGestureText=“Ctrl+P“ /> <MenuItem Header=“E_xport“ Name=“Export“ InputGestureText=“Ctrl+X“ /> <Separator/> <MenuItem Header=“_Exit“ Name=“Exit“ InputGestureText=“ALT+F4″ /> </MenuItem> <MenuItem Header=“_Options“ Name=“Options“ /> <MenuItem Header=“_Help“ Name=“Help“ /> </Menu> <ScrollViewer Grid.Row=“1″> <DockPanel Name=“DP“ Background=“LightBlue“ ScrollViewer.CanContentScroll=“True“ ScrollViewer.HorizontalScrollBarVisibility=“visible“ ScrollViewer.VerticalScrollBarVisibility=“visible“ > <DataGrid /> </ DockPanel> </ScrollViewer> </Grid> </Window>

image

Das DataGrid hat sich nun, wie im XAML beschrieben, über das DockPanel gelegt. Da wir noch keine Daten an das DataGrid übergeben haben, wird aktuell nur ein leerer Bereich dargestellt. Dies wird sich aber im nächsten Teil dieser Serie ändern.

Auch wenn es zu den Steuerelementen noch viel zu sagen gäbe, möchte ich die Ausführungen dazu beenden und Ihnen noch ein wenig Raum lassen, um selber damit zu experimentieren. Doch bevor wir dazu kommen, noch ein Wort zu Formatierungen von Steuerelementen (setzen von Attributen)

Formatierung

In den bisherigen Beispielen haben wir Formatierungen für jedes Steuerelement individuell vorgenommen. Die ist sicherlich bei einer so kleinen Anwendung auch problemlos möglich. Doch bei komplexeren Aufgaben oder bei der Einhaltung entsprechender Designvorgaben (z. B. Corporate Designs) gestaltet sich dies wesentlich komplexer.

Um dies zu vereinfachen, gibt es die Möglichkeit Formatierungen von Steuerelementen pro Steuerelement-Typ zentral in einem eigenen Bereich festzulegen. Die Formatierung von einzelnen Steuerelementen lässt sich natürlich trotzdem auch weiterhin individuell festlegen.

Dieser Bereich hat das Tag “<Windows.Resources>” und befindet sich eingebettet in der XAML-Struktur nach dem “<Windows>”-Tag. In dem folgenden Beispiel habe ich die Definition der Eigenschaften der Steuerelemente ich eine eigene PowerShell-Variable ausgelagert. Dies ist natürlich nicht notwendig. Sollten Sie jedoch mit mehreren Fenstern innerhalb einer Anwendung arbeiten, können Sie so automatisch alle Formatierungen aller Fenster vereinheitlichen.

$Style=@" 
<Window.Resources> 
    <Style TargetType="{x:Type Label}">
        <Setter Property="VerticalAlignment" Value="Top" /> 
        <Setter Property="Margin" Value="0,0,0,10" />
        <Setter Property="Background" Value="Transparent" />
        <Setter Property="BorderBrush" Value="Transparent" />
        <Setter Property="FontWeight" Value="Bold" />
    </Style>
    <Style TargetType="{x:Type DataGrid}">
        <Setter Property="AutoGenerateColumns" Value="True" />
        <Setter Property="HorizontalAlignment" Value="Left" />
        <Setter Property="VerticalAlignment" Value="Top" />
        <Setter Property="IsReadOnly" Value="True" />
        <Setter Property="RowBackground" Value="#FFE6E6E6" />
        <Setter Property="AlternatingRowBackground" Value="White" />
        <Setter Property="AlternationCount" Value="2"/>
        <Setter Property="CanUserReorderColumns" Value="True" />
        <Setter Property="CanUserResizeColumns" Value="True" />
        <Setter Property="CanUserResizeRows" Value="True" />
        <Setter Property="CanUserSortColumns" Value="True" />
    </Style>
    <Style TargetType="{x:Type DataGridColumnHeader}">
        <Setter Property="VerticalContentAlignment" Value="Center" />
        <Setter Property="Background" Value="LightGray" />
        <Setter Property="FontWeight" Value="Bold" />
    </Style> 
</Window.Resources> 
"@

Fazit

Wie ich Ihnen in diesem Teil der Artikelserien hoffentlich anschaulich beschrieben habe, ist die Gestaltung von Oberflächen sehr einfach und bietet trotzdem viele Möglichkeiten. Mein Ziel dieses Artikels war nicht aus Ihnen einen perfekten Designer für WPF-Anwendungen zu machen, doch ich wollte Ihnen zeigen, wie Sie mit wenigen Zeilen XAML anspruchsvolle Benutzeroberflächen für Windowsanwendungen gestalten können. Sollten Sie Gefallen an dieser Technologie gefunden haben, kann ich Ihnen ein gutes Buch zu diesem Thema empfehlen bzw. den Tipp geben, sich im Internet in Foren und Blogs darüber zu informieren.

Die Interaktion mit dem Anwender und die Verarbeitung von Daten innerhalb der Anwendung zeige ich Ihnen dann in dem nächsten Teil dieser Artikelserie.

Zum Schluss noch die Gesamtanwendung mit allen Elementen, die wir bisher in das PowerShell-Skript integriert haben:

$Style=@" 
<Window.Resources> 
    <Style TargetType="{x:Type Label}"> 
        <Setter Property="VerticalAlignment" Value="Top" /> 
        <Setter Property="Margin" Value="0,0,0,10" /> 
        <Setter Property="Background" Value="Transparent" /> 
        <Setter Property="BorderBrush" Value="Transparent" /> 
        <Setter Property="FontWeight" Value="Bold" /> 
        </Style> 
    <Style TargetType="{x:Type DataGrid}"> 
        <Setter Property="AutoGenerateColumns" Value="True" /> 
        <Setter Property="IsReadOnly" Value="True" /> 
        <Setter Property="RowBackground" Value="#FFE6E6E6" /> 
        <Setter Property="AlternatingRowBackground" Value="White" /> 
        <Setter Property="AlternationCount" Value="2"/> 
        <Setter Property="CanUserReorderColumns" Value="True" /> 
        <Setter Property="CanUserResizeColumns" Value="True" /> 
        <Setter Property="CanUserResizeRows" Value="True" /> 
        <Setter Property="CanUserSortColumns" Value="True" /> 
    </Style> 
    <Style TargetType="{x:Type DataGridColumnHeader}"> 
        <Setter Property="VerticalContentAlignment" Value="Center" /> 
        <Setter Property="Background" Value="LightGray" /> 
        <Setter Property="FontWeight" Value="Bold" /> 
        </Style> 
</Window.Resources> 
"@ 
[xml] $xaml = @"
<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Test-Anwendung" Height="200" Width="200">
$Style
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>
        <Menu Height="22" Name="menu1" VerticalAlignment="Top" Grid.Row="0">
            <MenuItem Header="_File" Name="File">
                <MenuItem Header="_Open" Name="Open" InputGestureText="Ctrl+O" />
                <MenuItem Header="_Close" Name="Close" InputGestureText="Ctrl+T" />
                <MenuItem Header="_Print" Name="Print" InputGestureText="Ctrl+P" />
                <MenuItem Header="E_xport" Name="Export" InputGestureText="Ctrl+X" />
                <Separator/>
                <MenuItem Header="_Exit" Name="Exit" InputGestureText="ALT+F4" />
                </MenuItem>
            <MenuItem Header="_Options" Name="Options" />
            <MenuItem Header="_Help" Name="Help" />
        </Menu>
        <ScrollViewer Grid.Row="1">
            <DockPanel Name="DP" Background="LightBlue"
                ScrollViewer.CanContentScroll="True"
                ScrollViewer.HorizontalScrollBarVisibility="Auto"
                ScrollViewer.VerticalScrollBarVisibility="Auto">
                <DataGrid Name="DG1" />
            </DockPanel>
        </ScrollViewer>
    </Grid>
</Window>
"@
Add-Type -Assembly PresentationFramework 
$reader=(New-Object System.Xml.XmlNodeReader $xaml)
$Form=[Windows.Markup.XamlReader]::Load( $reader )
$c = $Form.ShowDialog()
Advertisements
Über

Die IT-Welt wird immer komplexer und zwischen den einzelnen Komponenten gibt es immer mehr Abhängigkeiten. Nachdem ich durch meine tägliche Arbeit immer wieder vor der Herausforderung stehe, komplexe Probleme zu lösen, möchte ich diese Seite dafür verwenden, Euch den einen oder anderen Tipp zu geben, wenn Ihr vor ähnlichen Aufgabenstellungen steht.

Veröffentlicht in PowerShell, WPF

Kommentar verfassen

Trage deine Daten unten ein oder klicke ein Icon um dich einzuloggen:

WordPress.com-Logo

Du kommentierst mit Deinem WordPress.com-Konto. Abmelden / Ändern )

Twitter-Bild

Du kommentierst mit Deinem Twitter-Konto. Abmelden / Ändern )

Facebook-Foto

Du kommentierst mit Deinem Facebook-Konto. Abmelden / Ändern )

Google+ Foto

Du kommentierst mit Deinem Google+-Konto. Abmelden / Ändern )

Verbinde mit %s

%d Bloggern gefällt das: