## 19.6 FlowDocuments ### 19.6.1 Allgemeine Beschreibung Mit den Steuerelementen Label und TextBlock haben Sie auf den letzten Seiten zwei Steuerelemente kennengelernt, die zur Laufzeit keine Textänderungen zulassen. Mit einer TextBox-Komponente ermöglichen Sie dem Anwender auf der einen Seite, eigene Einträge vorzunehmen. Der eingegebene Text ist allerdings unformatiert, das bedeutet, in einer TextBox kann der Inhalt nur in einer Schriftart dargestellt werden, er ist entweder komplett fett oder kursiv, lässt auch keine anderen optischen Hervorhebungen (beispielsweise durch unterschiedliche Farbwahl) zu. Verglichen mit den Möglichkeiten, die selbst HTML bietet, ist das geradezu erbärmlich, es genügt aber den Anforderungen, die an ein einfaches Eingabesteuerelement gestellt werden. Hinsichtlich der Verarbeitung und Darstellung von Text hat die WPF aber noch weitaus mehr zu bieten als die genannten einfachen Steuerelemente Label oder TextBox. Eins haben Sie bereits kennengelernt, nämlich TextBlock. Genau genommen ist TextBlock jedoch kein Steuerelement, da es nicht von Control abgeleitet ist. Aber ein TextBlock lässt bereits kurze, formatierte Texte zu. Sollen innerhalb eines Dokuments darüber hinaus auch Listen, Tabellen oder Bilder angezeigt werden, ist auch TextBlock an den Grenzen seiner Fähigkeiten angelangt. Für solche Anwendungsfälle bietet Ihnen die WPF mit FlowDocumentReader FlowDocumentPageViewer FlowDocumentScrollViewer drei weitere Steuerelemente an, mit denen praktisch beliebig strukturierte Dokumente in einem Window oder einer Page angezeigt werden können. Ehe wir uns aber diesen drei Steuerelementen widmen, müssen wir uns damit auseinandersetzen, wie der anzuzeigende Dokumentinhalt definiert wird, der im allgemeinen als FlowDocument bezeichnet wird. Bei einem FlowDocument handelt es sich also um ein Dokument, das in einem der drei zuvor angeführten Viewer angezeigt werden kann. Im XAML-Code wird das FlowDocument im Viewer eingebettet, wie im folgenden Listing gezeigt wird:
    <FlowDocumentReader>
      <FlowDocument>
        <!-- Inhalt, der durch Blöcke beschrieben wird -->
      </FlowDocument>
    </FlowDocumentReader>
Für ein FlowDocument gibt es klare Richtlinien, die die Darstellung und den strukturellen Aufbau beschreiben. Ein FlowDocument setzt sich aus einem oder mehreren sogenannten Blöcken zusammen. Es stehen Ihnen insgesamt fünf verschiedene Block-Typen mit einer Vielzahl von Eigenschaften zur Verfügung, die dem FlowDocument das gewünschte Aussehen und Verhalten verleihen. Bei den Blöcken handelt es sich um Section, Paragraph, List, Table und BlockUIContainer.
Hinweis
Genau genommen kennen Sie bereits ein FlowDocument. Es handelt sich um den weiter oben behandelten TextBlock. Ein TextBlock gestattet jedoch nur die Anzeige einfacher Elemente. Weitergehende Darstellungsformen, beispielsweise die Anzeige einer Liste oder einer Tabelle, werden von der TextBlock-Komponente nicht angeboten. Ein TextBlock benötigt keinen separaten Viewer, denn dieses Steuerelement ist FlowDocument und Viewer gleichzeitig.
### 19.6.2 Eigenschaften eines FlowDocuments Um ein FlowDocument zu beschreiben, stehen Ihnen viele Eigenschaften zur Verfügung. Einige sind Ihnen bereits geläufig, beispielsweise Padding, Margin, FontStyle usw. Auf einige spezifische Eigenschaften soll aber an dieser Stelle eingegangen werden. Sehen Sie sich dazu bitte Tabelle 19.9 an.

Tabelle 19.9 Eigenschaften eines FlowDocuments

Eigenschaft | Beschreibung
IsHyphenationEnabled | Diese Eigenschaft gibt an, ob eine Silbentrennung durchgeführt werden soll.
IsOptimalParagraphEnabled | Wird diese Eigenschaft auf true gestellt, wird der Absatzumbruch optimiert. Das vermindert zu große Abstände zwischen den Wörtern.
LineHeight | Diese Eigenschaft gibt den Zeilenabstand innerhalb eines Absatzes an.
Style | Mit dieser Eigenschaft können Sie Formatierungen durch externe Styles beschreiben. Wir werden später in diesem Buch die Styles noch thematisieren.
TextAlignment | Diese Eigenschaft gibt die Textausrichtung an und kann auf Left, Right, Center und Justify eingestellt werden.
Anmerkung
Dieses Buch kann nur eine mehr oder weniger oberflächliche Einführung in die FlowDocuments sein. Für eine umfassende Beschreibung aller WPF-Klassen und deren Fähigkeiten reicht der Platz einfach nicht aus. Daher sei auch an dieser Stelle auf die MSDN-Online-Hilfe verwiesen, die diesbezüglich natürlich deutlich mehr Informationen liefert.
### 19.6.3 Blöcke eines FlowDocuments FlowDocumente beschreiben einen textuellen Inhalt. Die Darstellung erfolgt, wie nicht anders zu erwarten ist, in XML. Die Grundstruktur eines FlowDocument setzt sich aus einem oder mehreren sogenannten Blöcken zusammen, wobei Ihnen zur Gestaltung der Grundstruktur fünf unterschiedliche Blöcke zur Verfügung stehen, die Sie Tabelle 19.10 entnehmen können. Alle Blöcke werden durch entsprechende Klassen beschrieben und haben die Basis Block, die zum Namespace System.Windows.Documents gehört.

Tabelle 19.10 Blöcke eines FlowDocuments

Block | Beschreibung
Paragraph | Ein Paragraph-Element beschreibt Text. Dieses Element beschreibt also gewissermaßen das Fleisch des FlowDocument.
    <Paragraph>
      <!—Textinhalt -->
    </Paragraph>
Section | Das Section-Element dient dazu, mehrere Blöcke zusammenzuführen, um eine einheitliche Formatierung aller enthaltenen Blöcke zu erreichen.
    <Section>
      <!—weitere Blöcke -->
    </Section>
List | Das List-Element beschreibt eine Collection von ListItem-Elementen. Damit werden Listen innerhalb eines FlowDocument beschrieben. Jedes ListItem-Element darf seinerseits einen beliebigen Block-Typ enthalten, natürlich auch wieder selbst ein List-Element, um eine verschachtelte Liste abzubilden.
Table | Das Table-Element bildet eine Tabelle ab. Jede Zelle der Tabelle darf einen beliebigen Block-Typ enthalten.
BlockUIContainer | Das BlockUIElement kann ein beliebiges UIElement-Element enthalten, beispielsweise einen Button oder eine TextBox. Damit lassen sich BlockDocuments erstellen, die programmierbar sind.
    <BlockUIContainer>
      <Button... />
    </BlockUIContainer>
Paragraph, Section und BlockUIContainer sind recht simpel und bedürfen keiner weiteren Beschreibung. List und Table hingegen sind etwas komplexer, sodass wir uns mit diesen beiden Blöcken weiter unten noch genauer beschäftigen werden. #### Beispielprogramm Das folgende Beispielprogramm FlowDocumentDemo zeigt, wie ein FlowDocument in XAML-Code aussieht. Um das Grundprinzip zu verdeutlichen, wird in diesem Beispiel nur der Paragraph-Block verwendet.
    // -----------------------------------------------------
    // Beispiel: ...\Kapitel 19\FlowDocumentDemo
    // -----------------------------------------------------
    <FlowDocumentReader>
      <FlowDocument>
        <Paragraph FontSize="20" FontFamily="Arial"
                   FontWeight="Bold" Foreground="Blue">
          Kapitel 3: das Klassendesign
        </Paragraph>
        <Paragraph FontSize="16" FontFamily="Arial" FontWeight="Bold">
          3.1 Einführung in die Objektorientierung
        </Paragraph>
        <Paragraph FontSize="12" FontFamily="Arial">
          Die beiden wichtigsten ...
        </Paragraph>
        <Paragraph FontSize="12" FontFamily="Arial">
          Stellen Sie sich ein Architekturbüro ...
        </Paragraph>
        <Paragraph FontSize="12" FontFamily="Arial">
          Der Bauplan dient also ...
        </Paragraph>
      </FlowDocument>
    </FlowDocumentReader>
In Abbildung 19.14 sehen Sie die Ausgabe des FlowDocument. Hier klicken, um das Bild zu vergrößern Abbildung 19.14 Ausgabe des FlowDocuments Fließtexte werden in Paragraph-Elementen beschrieben. Das Beispielprogramm zeigt allerdings nur den einfachen Einsatz der Fließtexte. Wie schon angedeutet, können Sie auch innerhalb eines Textes einzelne Wörter oder Passagen unterschiedlich formatieren. Dazu dienen Inline-Elemente, mit denen wir uns weiter unten noch beschäftigen werden. Zuvor aber sollten wir uns noch zwei der in Tabelle 19.10 aufgeführten Block-Elemente etwas detaillierter ansehen: List und Table. #### Der »List«-Block Etwas komplexer als die Elemente Paragraph, Section und BlockUIContainer ist das Element List. Dieses Block-Element dient zum Erzeugen von Aufzählungen. Jeder Listeneintrag wird innerhalb von List durch ein ListItem-Element beschrieben. ListItem-Elemente beinhalten ihrerseits Blockelemente, sodass Sie den anzuzeigenden Text zum Beispiel in ein Paragraph-Element einschließen. Mit der Eigenschaft MarkerStyle des List-Elements legen Sie das Aufzählungszeichen fest. Es entstammt der Enumeration TextMarkerStyle und enthält zehn verschiedene Varianten, angefangen bei einfachen Symbolen bis hin zu Zahlen und Buchstaben. Verwenden Sie Zahlen, kann mit der Eigenschaft StartIndex der Index des ersten Elements festgelegt werden. Den Abstand zwischen den Aufzählungszeichen und dem Text des Listeneintrags können Sie bei Bedarf mit der Eigenschaft MarkerOffset definieren.
    <List MarkerStyle="Decimal" FontFamily="Arial">
      <ListItem>
        <Paragraph>Erster Listeneintrag</Paragraph>
      </ListItem>
      <ListItem>
        <Paragraph>Zweiter Listeneintrag</Paragraph>
      </ListItem>
    </List>
#### Der »Table«-Block Das komplexeste Blockelement beschreibt eine Tabelle und wird mit Table eingeleitet. Innerhalb des Table-Elements werden mit TableRowGroup alle Zeilen innerhalb der Tabelle beschrieben. Ausgedrückt wird dabei jede Zeile durch ein TableRow-Element, jede Zelle der Datenzeile durch das Element TableCell. Ein Table-Element kann auch mehrere TableRowGroup-Elemente enthalten. Das macht Sinn, wenn mehrere Zeilen innerhalb der Tabelle unterschiedlich formatiert werden sollen. Geben Sie innerhalb einer Tabellendefinition keine Spalten an, werden diese alle gleich breit dargestellt. Möchten Sie jedoch Einfluss auf die Spaltenbreiten ausüben, sollten Sie im Table-Element auch einen Table.Columns-Abschnitt definieren, der als Container für die definierten TableColumn-Elemente dient. Geben Sie jedem TableColumn-Element die gewünschte Breite mit Width an. Dabei können Sie entweder die absolute Breite einstellen, z. B. mit Width=70, oder die relative Breite, beispielsweise mit Width=3*.
    <Table CellSpacing="10" Padding="0" Background="Yellow"
           FontFamily="Arial" FontSize="12">
      <!-- Spaltendefinition -->
      <Table.Columns>
        <TableColumn Width="70" />
        <TableColumn Width="120" />
        <TableColumn Width="200"/>
        </Table.Columns>
      <!-- Zeilendefinition -->
      <TableRowGroup Background="LightCyan">
        <TableRow>
          <TableCell BorderThickness="1" BorderBrush="Black">
            <Paragraph>Zelle 0,0</Paragraph>
          </TableCell>
          <TableCell BorderThickness="1" BorderBrush="Black">
            <Paragraph>Zelle 0,1</Paragraph>
          </TableCell>
          <TableCell BorderThickness="1" BorderBrush="Black">
            <Paragraph>Zelle 0,2</Paragraph>
          </TableCell>
          </TableRow>
          <TableRow>
          <TableCell BorderThickness="1" BorderBrush="Black" >
            <Paragraph>Zelle 1,0</Paragraph>
          </TableCell>
          <TableCell BorderThickness="1" BorderBrush="Black">
            <Paragraph>Zelle 1,1</Paragraph>
          </TableCell>
          <TableCell BorderThickness="1" BorderBrush="Black">
            <Paragraph>Zelle 1,2</Paragraph>
          </TableCell>
        </TableRow>
      </TableRowGroup>
    </Table>
### 19.6.4 Inline-Elemente Innerhalb eines Fließtextes können Formatierungen am Text vorgenommen werden. Dazu dienen Inline-Elemente, die intern von der abstrakten Klasse Inline abgeleitet sind. LineBreak: Mit diesem Element wird ein Zeilenumbruch durchgeführt. Bold, Italic und Underline: Diese Inline-Elemente formatieren den enthaltenen Text fett, kursiv oder unterstrichen. Sie können Inline-Elemente grundsätzlich auch ineinander verschachteln, also Textpassagen auch fett und gleichzeitig kursiv darstellen, wie im folgenden XAML-Code gezeigt wird:
    <Paragraph>
      Ein typisches Urlaubsland ist
      <Italic><Bold>Österreich</Bold></Italic>.
    </Paragraph>
Figure: Das Element Figure können Sie sich als ein FlowDocument vorstellen, das in einen anderen, übergeordneten Bereich eingebettet wird, beispielsweise in das Paragraph-Element. Der umgebende Inhalt umschließt das Figure-Element, wobei Sie mit den Eigenschaften HorizontalAnchor und VerticalAnchor sowie HorizontalAnchor und VerticalAnchor die Positionierung beliebig selbst festlegen dürfen. Height und Width legen dabei die Abmessungen fest. Sollte der gewünschte Inhalt nicht in das Figure-Element passen, wird er abgeschnitten. Das Element eignet sich gut für Werbung, Zusatzinformationen oder auch Bilder. Floater: Das Floater-Element ist eine vereinfachte Form des Figure-Elements. Im Gegensatz zu Figure kann es nicht positioniert werden. Der Inhalt wird dort angezeigt, wo entsprechender Platz zur Verfügung steht. Für ein Floater-Element können Sie weder eine Offset-, noch eine Anchor-Eigenschaft angeben. Im Allgemeinen eignen sich Floater eher zum Einfügen fortlaufender Inhalte. InlineUIContainer: Dieses Element verwenden Sie, um andere UIElement-Elemente in den Fließtext einzubetten, beispielsweise einen Button. Mit diesem Element können Sie zwar nur UI-Elemente direkt angeben, aber es steht Ihnen frei, dazu einen Container zu verwenden, der natürlich seinerseits mehrere Elemente aufnehmen kann. Im Großen und Ganzen ähnelt es dem Element BlockUIContainer. Span: Obwohl Sie mit den Elementen Bold, Underline und Italic Möglichkeiten haben, einzelne Passagen des Textes besonders darzustellen, reichten diese oft nicht aus. Hier kommt das Span-Element ins Spiel, das wesentlich mehr Gestaltungsspielraum bietet. So lassen sich einzelne Wörter oder Passagen mit FontFamily in einer anderen Schriftart darstellen, oder Sie können mit Background die Hintergrundfarbe anders festlegen als im restlichen Teil des Dokuments.
    <Paragraph>
      Dies ist
      <Span Background="Yellow"
            Foreground="Blue"
            FontFamily="Californian FB">
        ein Beispiel
      </Span> für das
      <Span FontFamily="Courier New">
        Span
      </Span>-Element.
    </Paragraph>
Hyperlink: Dieses Element stellt einen Hyperlink dar. Dem Attribut NavigateUri geben Sie einen URI an, der nach dem Klicken auf das Element angezeigt werden soll. Stellen Sie dem URI das Zeichen # voran, können Sie sogar zu einer benannten Stelle im Dokument wechseln. Mit dem Attribut TargetName legen Sie das Ziel der Navigation fest. Dabei kann es sich zum Beispiel um ein Fenster oder einen Frame handeln. Run: Das Element Run gibt einen unformatierten Text aus. Dieser kann durch umschließende Elemente wieder eine eigene Formatierung erhalten. Das folgende Beispielprogramm demonstriert den Einsatz des Figure-Elements. Sicher ist das Layout des Windows durchaus verbesserungsbedürftig, aber dem Autor fehlt dazu einfach die erforderliche Begabung ...
    // -------------------------------------------------------
    // Beispiel: ...\Kapitel 19\FigureElement
    // -------------------------------------------------------
    <FlowDocumentReader>
      <FlowDocument>
        <Paragraph FontSize="22" Background="LightBlue" FontStyle="Oblique"
                   FontFamily="Arial" TextAlignment="Center" Padding="10">
          <TextBlock  VerticalAlignment="Center">
            <Bold>Seychellen-Infos</Bold>
          </TextBlock>
        </Paragraph>
        <Paragraph FontFamily="Arial" FontSize="15">
          Zu den vermutlich schönsten ...
          <Figure Width="150" HorizontalAnchor="PageLeft"
                              VerticalAnchor="PageCenter"
                              HorizontalOffset="0"
                              VerticalOffset="40">
            <BlockUIContainer>
              <Image  Source="1.jpg"></Image>
            </BlockUIContainer>
          </Figure>
          <Figure Width="150" HorizontalAnchor="PageRight"
                              VerticalAnchor="PageCenter"
                              VerticalOffset="-5">
            <BlockUIContainer>
              <Image Source="2.jpg"></Image>
            </BlockUIContainer>
          </Figure>
        </Paragraph>
      </FlowDocument>
      </FlowDocumentReader>
Hier klicken, um das Bild zu vergrößern Abbildung 19.15 Die Ausgabe des Beispiels »FigureElement«
Anmerkung
Alle hier behandelten Inline-Elemente wurden in den Codebeispielen in Paragraph-Elementen verwendet. Grundsätzlich unterstützt aber auch das TextBlock-Element alle Inlines.
### 19.6.5 FlowDocuments mit Code erzeugen Nicht immer werden Sie Ihre FlowDocuments im XAML-Code von Visual Studio bereitstellen können. Hier bieten sich Ihnen zwei weitere Alternativen an: Sie beschreiben den Inhalt des FlowDocument mit Programmcode. Sie greifen auf eine bereitgestellte XAML-Datei zurück. In diesem Abschnitt wollen wir uns zunächst mit der Codierung beschäftigen, daran anschließend mit dem Einlesen aus einer Datei. Das Schreiben des Programmcodes wird zu einem mittleren Drama. Nicht die Komplexität ist dafür verantwortlich, sondern vielmehr der Gesamtumfang. Vielleicht sollten Sie sich daher zunächst einmal Abbildung 19.16 ansehen. Hier klicken, um das Bild zu vergrößern Abbildung 19.16 Ausgabe des Beispielprogramms »FlowDocument_mit_Code« Eigentlich wird nicht viel dargestellt; das FlowDocument enthält auch keine besonderen »Spezialitäten«. Doch schauen Sie sich jetzt den Beispielcode an, der dieser Ausgabe zugrunde liegt.
    // -------------------------------------------------------
    // Beispiel: ...\Kapitel 19\FlowDocument_mit_Code
    // -----------------------------------------------------
    private void Window_Loaded(object sender, RoutedEventArgs e) {
      FlowDocumentReader flowReader = new FlowDocumentReader();
      FlowDocument document = new FlowDocument();
      flowReader.Document = document;
      this.Content = flowReader;
      // 1. Block – Paragraph
      Paragraph para1 = new Paragraph();
      para1.FontSize = 22;
      para1.Background = new SolidColorBrush(Colors.LightBlue);
      para1.FontFamily = new FontFamily("Arial");
      para1.TextAlignment = TextAlignment.Center;
      para1.Padding = new Thickness(10);
      TextBlock textBlock1 = new TextBlock();
      textBlock1.VerticalAlignment = System.Windows.VerticalAlignment.Center;
      textBlock1.Inlines.Add(new Bold(new Run("Wir planen ...")));
      para1.Inlines.Add(textBlock1);
      document.Blocks.Add(para1);
      // 2. Block – Paragraph
      Paragraph para2 = new Paragraph();
      TextBlock textBlock2 = new TextBlock();
      textBlock2.FontSize = 14;
      textBlock2.TextWrapping = TextWrapping.Wrap;
      textBlock2.FontFamily = new FontFamily("Arial");
      textBlock2.Inlines.Add(new Run("Buchen Sie ..."));
      para2.Inlines.Add(textBlock2);
      document.Blocks.Add(para2);
      // 3. Block – Tabelle
      Table table = new Table();
      table.FontFamily = new FontFamily("Arial");
      // 1. Spalte
      TableColumn col1 = new TableColumn();
      col1.Width = new GridLength(350);
      table.Columns.Add(col1);
      // 2. Spalte
      TableColumn col2 = new TableColumn();
      col2.Width = new GridLength(100);
      table.Columns.Add(col2);
      TableRowGroup rowGroup = new TableRowGroup();
      TableRow row1 = new TableRow();
      // Zelle 1, Reihe 1
      TableCell cell00 = new TableCell(
         new Paragraph(new Run("Australien - 3 wöchige Rundreise")));
      cell00.BorderThickness = new Thickness(1);
      cell00.BorderBrush = new SolidColorBrush(Colors.Black);
      row1.Cells.Add(cell00);
      // Zelle 2, Reihe 1
      TableCell cell01 = new TableCell(new Paragraph(new Run("5570,-€")));
      cell01.TextAlignment = TextAlignment.Right;
      cell01.BorderThickness = new Thickness(1);
      cell01.BorderBrush = new SolidColorBrush(Colors.Black);
      row1.Cells.Add(cell01);
      rowGroup.Rows.Add(row1);
      table.RowGroups.Add(rowGroup);
      document.Blocks.Add(table);
    }
Erstellt wird das FlowDocument im Ereignis Loaded des Window. Als Viewer des Dokuments wird auch in diesem Fall ein FlowDocumentReader benutzt. Das FlowDocument beschreibt drei Blöcke, unter ihnen eine Tabelle. Um den Code nicht unnötig aufzublähen, ist in der Tabelle nur eine Zeile definiert. Das wird aber ausreichen, um den Ablauf zu erklären. Sehen wir uns exemplarisch die erste Paragraph-Definition an. Ein Paragraph-Objekt verwaltet eine Collection von Inline-Objekten, die über die Eigenschaft Inlines veröffentlicht wird. Jedes zu einem Paragraph-Objekt gehörende Inline-Objekt muss dieser Collection hinzugefügt werden. In unserem Beispielprogramm handelt es sich um ein TextBlock-Objekt. Sehr ähnlich wird auch das zweite Paragraph-Objekt behandelt. Ein Table-Block beschreibt mindestens ein TableGroup-Objekt, das seinerseits mehrere Zeilen beherbergt. Eine Zeile wiederum ist durch TableCell-Objekte beschrieben. Jedes TableCell-Objekt muss der Collection aller Zellen einer Tabellenzeile hinzugefügt werden, zum Beispiel so:
    row1.Cells.Add(cell00);
row1 ist hierbei die Referenz einer Tabellenzeile. Mit
    rowGroup.Rows.Add(row1);
wird die Zeile zum Mitglied des TableRowGroup-Objekts. Die TableRowGroup wird mit
    table.RowGroups.Add(rowGroup);
zu einem Mitglied der Tabelle. Ein FlowDocument beschreibt mit einer Collection vom Typ BlockCollection alle in ihm enthaltenen Blöcke. Natürlich müssen auch diese Blöcke erst dem Dokument bekannt gegeben werden. Im Fall unserer Tabelle ist das die Anweisung
    document.Blocks.Add(table);
Das FlowDocument muss natürlich auch noch dem Viewer übergeben werden, der sich selbst auch noch dem Window-Objekt bekannt machen muss. Hierfür sind die beiden Anweisungen
    flowReader.Document = document;
    this.Content = flowReader;
zuständig. ### 19.6.6 Speichern und Laden von FlowDocuments Sie können ein FlowDocument als XAML-Datei speichern. Hierbei kommt die Klasse XamlWriter ins Spiel, deren Namespace System.Windows.Markup Sie mit using bekannt geben sollten. Mit der statischen Methode Save() der Klasse wird das Dokument in die angegebene Datei geschrieben.
    FileStream fs = new FileStream(@"C:\test.xaml", FileMode.Create);
    XamlWriter.Save(FlowDocument, fs);
    fs.Close();
Zum Laden eines FlowDocument kommt die Klasse XamlWriter zum Einsatz. Hier ist es die statische Methode Load(), die das Laden initiiert.
    File.OpenRead(@"C:\test.xaml");
    DocumentViewer.DocumentProperty = XamlReader.Load(fs);
    fs.Close();