Übersetzen Sie Markdown in Document Object Model (DOM)

Um den Inhalt und die Formatierung eines Dokuments programmgesteuert zu lesen, zu bearbeiten und zu ändern, müssen Sie es in Aspose.Words Document Object Model (DOM) übersetzen.

Im Gegensatz zu Word-Dokumenten entspricht Markdown nicht dem im Aspose.Words Document Object Model (DOM)-Artikel beschriebenen DOM. Aspose.Words bietet jedoch einen eigenen Mechanismus zum Übersetzen von Markdown-Dokumenten in DOM und zurück, sodass wir erfolgreich mit ihren Elementen wie Textformatierung, Tabellen, Kopfzeilen und anderen arbeiten können.

In diesem Artikel wird erläutert, wie die verschiedenen markdown-Funktionen in das Aspose.Words-DOM- und zurück in das Markdown-Format übersetzt werden können.

Komplexität der Übersetzung Markdown – DOM – Markdown

Die Hauptschwierigkeit dieses Mechanismus besteht nicht nur darin, Markdown in DOM zu übersetzen, sondern auch die umgekehrte Transformation durchzuführen – das Dokument mit minimalem Verlust wieder im Markdown-Format zu speichern. Es gibt Elemente, wie z. B. mehrstufige Anführungszeichen, für die die umgekehrte Transformation nicht trivial ist.

Mit unserer Übersetzungs-Engine können Benutzer nicht nur mit komplexen Elementen in einem vorhandenen Markdown-Dokument arbeiten, sondern auch ihr eigenes Dokument im Markdown-Format mit der Originalstruktur von Grund auf erstellen. Um verschiedene Elemente zu erstellen, müssen Sie Stile mit bestimmten Namen gemäß bestimmten Regeln verwenden, die später in diesem Artikel beschrieben werden. Solche Stile können programmgesteuert erstellt werden.

Gemeinsame Übersetzungsprinzipien

Wir verwenden Font-Formatierung für Inline-Blöcke. Wenn es keine direkte Entsprechung für eine Markdown-Funktion in Aspose.Words-DOM gibt, verwenden wir einen Zeichenstil mit einem Namen, der mit einigen speziellen Wörtern beginnt.

Für Containerblöcke verwenden wir Stilvererbung, um verschachtelte Markdown-Funktionen zu kennzeichnen. In diesem Fall verwenden wir auch dann Absatzstile, deren Namen mit einigen speziellen Wörtern beginnen, selbst wenn keine verschachtelten Funktionen vorhanden sind.

Aufzählungslisten und geordnete Listen sind in Markdown ebenfalls Containerblöcke. Ihre Verschachtelung wird in DOM auf die gleiche Weise wie bei allen anderen Containerblöcken mithilfe der Stilvererbung dargestellt. Darüber hinaus verfügen Listen in DOM jedoch über eine entsprechende Zahlenformatierung entweder im Listenstil oder in der Absatzformatierung.

Inline-Blöcke

Bei der Übersetzung von Bold-, Italic- oder Durchgestrichenen-Inline-markdown-Funktionen verwenden wir die Font-Formatierung.

Markdown-Funktion Aspose.Words
Bold
{1}		 Font.Bold = true
Italic
*italic text*		 Font.Italic = true
Strikethrough
~Strikethrough text~		 Font.StrikeThrough = true 
// Use a document builder to add content to the document.
DocumentBuilder builder = new DocumentBuilder();

// Make the text Strikethrough.
builder.Font.Strikethrough = true;
builder.Writeln("This text will be Strikethrough");

Wir verwenden einen Zeichenstil mit einem Namen, der mit dem Wort InlineCode beginnt, gefolgt von einem optionalen Punkt (.) und einer Reihe von Backticks (`) für die InlineCode-Funktion. Wenn mehrere Backticks fehlen, wird standardmäßig ein Backtick verwendet.

Markdown-Funktion Aspose.Words
InlineCode
{1}		 Font.StyleName = “InlineCode[.][N]”
Autolink
<scheme://domain.com>
<email@domain.com>		 Die FieldHyperlink-Klasse
Link
{1}
{2}
{3}
{4})		 Die FieldHyperlink-Klasse
Image
{1}
{2}
{3}
{4})		 Die Shape-Klasse

Containerblöcke

Ein Dokument ist eine Folge von Containerblöcken wie Überschriften, Absätzen, Listen, Zitaten und anderen. Containerblöcke können in zwei Klassen unterteilt werden: Leaf-Blöcke und komplexe Container. Blattblöcke können nur Inline-Inhalte enthalten. Komplexe Container wiederum können andere Containerblöcke enthalten, einschließlich Leaf-Blöcken.

Blattblöcke

Die folgende Tabelle zeigt Beispiele für die Verwendung von Markdown-Leaf-Blöcken in Aspose.Words:

Markdown-Funktion Aspose.Words
HorizontalRule
-----		 Dies ist ein einfacher Absatz mit einer entsprechenden HorizontalRule-Form:
DocumentBuilder.InsertHorizontalRule()
ATX Heading
# H1, ## H2, ### H3…		 ParagraphFormat.StyleName = “Heading N”, wobei (1<= N <= 9).
Dies wird in einen integrierten Stil übersetzt und sollte genau dem angegebenen Muster entsprechen (es sind keine Suffixe oder Präfixe zulässig).
Andernfalls handelt es sich nur um einen normalen Absatz mit einem entsprechenden Stil
Setext Heading
=== (wenn Überschriftenebene 1),
--- (wenn Überschriftenebene 2)		 ParagraphFormat.StyleName = “SetextHeading[some suffix]”, basierend auf dem “Heading N”-Stil.
Wenn (N >= 2), wird “Heading 2” verwendet, andernfalls “Heading 1”.
Jedes Suffix ist zulässig, aber der Aspose.Words-Importer verwendet die Zahlen “1” bzw. “2”		 
// Use a document builder to add content to the document.
DocumentBuilder builder = new DocumentBuilder();

builder.ParagraphFormat.StyleName = "Heading 1";
builder.Writeln("This is an H1 tag");

// Reset styles from the previous paragraph to not combine styles between paragraphs.
builder.Font.Bold = false;
builder.Font.Italic = false;

Style setexHeading1 = builder.Document.Styles.Add(StyleType.Paragraph, "SetextHeading1");
builder.ParagraphFormat.Style = setexHeading1;
builder.Document.Styles["SetextHeading1"].BaseStyleName = "Heading 1";
builder.Writeln("Setext Heading level 1");

builder.ParagraphFormat.Style = builder.Document.Styles["Heading 3"];
builder.Writeln("This is an H3 tag");

// Reset styles from the previous paragraph to not combine styles between paragraphs.
builder.Font.Bold = false;
builder.Font.Italic = false;

Style setexHeading2 = builder.Document.Styles.Add(StyleType.Paragraph, "SetextHeading2");
builder.ParagraphFormat.Style = setexHeading2;
builder.Document.Styles["SetextHeading2"].BaseStyleName = "Heading 3";

// Setex heading level will be reset to 2 if the base paragraph has a Heading level greater than 2.
builder.Writeln("Setext Heading level 2");
Indented Code ParagraphFormat.StyleName = “IndentedCode[some suffix]”
Fenced Code
``` c#
if ()
then
else
```
ParagraphFormat.StyleName = “FencedCode[.][info string]”
[.] und [info string] sind optional

Komplexe Container

Die folgende Tabelle zeigt Beispiele für die Verwendung komplexer Markdown-Container in Aspose.Words:

Markdown-Funktion Aspose.Words
Quote
> quote,
>> nested quote		 ParagraphFormat.StyleName = “Quote[some suffix]”
Das Suffix im Stilnamen ist optional, aber der Aspose.Words-Importer verwendet die geordneten Nummern 1, 2, 3, …. bei verschachtelten Anführungszeichen.
Die Verschachtelung wird über die geerbten Stile definiert		 
// Use a document builder to add content to the document.
DocumentBuilder builder = new DocumentBuilder();

// By default a document stores blockquote style for the first level.
builder.ParagraphFormat.StyleName = "Quote";
builder.Writeln("Blockquote");

// Create styles for nested levels through style inheritance.
Style quoteLevel2 = builder.Document.Styles.Add(StyleType.Paragraph, "Quote1");
builder.ParagraphFormat.Style = quoteLevel2;
builder.Document.Styles["Quote1"].BaseStyleName = "Quote";
builder.Writeln("1. Nested blockquote");
BulletedList
- Item 1
- Item 2
- Item 2a
- Item 2b		 Listen mit Aufzählungszeichen werden durch Absatznummerierung dargestellt:
ListFormat.ApplyBulletDefault()
Es gibt drei Arten von Listen mit Aufzählungszeichen. Sie unterscheiden sich nur im Nummerierungsformat der allerersten Ebene. Dies sind: ‘-’, ‘+’ bzw. ‘*’
OrderedList
1. Item 1
2. Item 2
1) Item 2a
2) Item 2b		 Geordnete Listen werden durch Absatznummerierung dargestellt:
ListFormat.ApplyNumberDefault()
Es können zwei Zahlenformatmarkierungen vorhanden sein: “.” Und ‘)’. Der Standardmarker ist “.”		 
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

builder.ListFormat.ApplyBulletDefault();
builder.ListFormat.List.ListLevels[0].NumberFormat = $"{(char) 0}.";
builder.ListFormat.List.ListLevels[1].NumberFormat = $"{(char) 1}.";

builder.Writeln("Item 1");
builder.Writeln("Item 2");

builder.ListFormat.ListIndent();

builder.Writeln("Item 2a");
builder.Writeln("Item 2b");

Tische

Aspose.Words ermöglicht auch die Übersetzung von Tabellen in DOM, wie unten gezeigt:

Markdown-Funktion Aspose.Words
Table
a | b
- | -
c | d		 Table-, Row- und Cell-Klassen 
// Use a document builder to add content to the document.
DocumentBuilder builder = new DocumentBuilder();

// Add the first row.
builder.InsertCell();
builder.Writeln("a");
builder.InsertCell();
builder.Writeln("b");

// Add the second row.
builder.InsertCell();
builder.Writeln("c");
builder.InsertCell();
builder.Writeln("d");

Siehe auch

Aspose.Words Document Object Model (DOM) in C# Übersicht über den Document Builder in C#