Freigeben über

Anwenden einer Formatvorlage auf einen Absatz in einem Dokument aus einem Textverarbeitungsprogramm

In diesem Thema wird gezeigt, wie Sie die Klassen im Open XML SDK für Office verwenden, um eine Formatvorlage programmgesteuert auf einen Absatz in einem Textverarbeitungsdokument anzuwenden. Es enthält eine Beispielmethode ApplyStyleToParagraph zur Veranschaulichung dieser Aufgabe sowie mehrere ergänzende Beispielmethoden, um zu überprüfen, ob eine Formatvorlage vorhanden ist, eine neue Formatvorlage hinzuzufügen und den Formatvorlagenteil hinzuzufügen.

ApplyStyleToParagraph-Methode

Die ApplyStyleToParagraph Beispielmethode kann verwendet werden, um eine Formatvorlage auf einen Absatz anzuwenden. Sie müssen zunächst einen Verweis auf das Dokument sowie einen Verweis auf den zu formatierenden Absatz abrufen. Die -Methode akzeptiert vier Parameter, die angeben: den Pfad zum zu öffnenden Textverarbeitungsdokument, die Styleid der anzuwendenden Formatvorlage, den Namen der anzuwendenden Formatvorlage und den Verweis auf den Absatz, auf den die Formatvorlage angewendet werden soll.

static void ApplyStyleToParagraph(WordprocessingDocument doc, string styleid, string stylename, Paragraph p)

In den folgenden Abschnitten in diesem Thema werden die Implementierung dieser Methode und der unterstützende Code sowie deren Aufruf erläutert. Den vollständigen Beispielcodeeintrag finden Sie im Abschnitt Beispielcode am Ende dieses Themas.

Abrufen eines WordprocessingDocument-Objekts

Im Abschnitt "Beispielcode" ist auch der Code dargestellt, der zum Einrichten des Aufrufs der Beispielmethode erforderlich ist. Wenn Sie die Methode zum Anwenden einer Formatvorlage auf einen Absatz in einem Dokument verwenden möchten, benötigen Sie zuerst einen Verweis auf das geöffnete Dokument. Im Open XML SDK stellt die WordprocessingDocument -Klasse ein Word-Dokumentpaket dar. Um ein Word Dokument zu öffnen und damit zu arbeiten, erstellen Sie eine instance der WordprocessingDocument -Klasse aus dem Dokument. Nachdem Sie die instance erstellt haben, verwenden Sie ihn, um Zugriff auf den Standard Dokumentteil zu erhalten, der den Text des Dokuments enthält. Der Inhalt des Hauptdokumentteils ist im Paket mithilfe des WordprocessingML-Markups als XML dargestellt.

Um die Klasse instance zu erstellen, rufen Sie eine der Überladungen der Open -Methode auf. Im folgenden Beispielcode wird die Verwendung der DocumentFormat.OpenXml.Packaging.WordprocessingDocument.Open(String, Boolean) Überladung veranschaulicht. Der erste Parameter enthält eine Zeichenfolge, die den vollständigen Pfad zu dem zu öffnenden Dokument darstellt. Der zweite Parameter akzeptiert den Wert oder truefalse und gibt an, ob die Datei zur Bearbeitung geöffnet werden soll. In diesem Beispiel wird true der -Parameter verwendet, um Lese-/Schreibzugriff auf die Datei zu aktivieren.

using (WordprocessingDocument doc = WordprocessingDocument.Open(args[0], true))

Struktur eines WordProcessingML-Dokuments

Die grundlegende Dokumentstruktur eines WordProcessingML Dokuments besteht aus den document Elementen und body gefolgt von einem oder mehreren Elementen auf Blockebene, z p. B. , die einen Absatz darstellen. Ein Absatz enthält mindestens ein r Element. Steht r für "run", bei dem es sich um einen Textbereich mit einem gemeinsamen Satz von Eigenschaften handelt, z. B. formatierung. Eine Ausführung enthält mindestens ein t Element. Das t -Element enthält einen Textbereich. Das folgende Codebeispiel zeigt das WordprocessingML Markup für ein Dokument, das den Text "Beispieltext" enthält.

    <w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
      <w:body>
        <w:p>
          <w:r>
            <w:t>Example text.</w:t>
          </w:r>
        </w:p>
      </w:body>
    </w:document>

Mit dem Open XML SDK können Sie Dokumentstrukturen und -inhalte mithilfe stark typisierter Klassen erstellen, die Elementen entsprechen WordprocessingML . Sie finden diese Klassen im DocumentFormat.OpenXml.Wordprocessing -Namespace. In der folgenden Tabelle sind die Klassennamen der Klassen aufgeführt, die den documentElementen , body, p, rund t entsprechen.

WordprocessingML-Element Open XML SDK-Klasse Beschreibung
<document/> Document Das Stammelement des Hauptdokumentteils.
<body/> Body Der Container für die Strukturen auf Blockebene, z. B. Absätze, Tabellen, Anmerkungen und andere, die in der Spezifikation ISO/IEC 29500 angegeben sind.
<p/> Paragraph Ein Absatz.
<r/> Run Ein Lauf.
<t/> Text Ein Textbereich.

Weitere Informationen zur Gesamtstruktur der Teile und Elemente eines WordprocessingML-Dokuments finden Sie unter Struktur eines WordprocessingML-Dokuments.

Abrufen des Absatzes in formatieren

Nach dem Öffnen der Datei ruft der Code einen Verweis auf den ersten Absatz ab. Da ein typischer Textkörper eines Textverarbeitungsdokuments viele Arten von Elementen enthält, filtert der Code die Nachfolger im Textkörper des Dokuments nach denen des Typs Paragraph. Die ElementAtOrDefault -Methode wird dann verwendet, um einen Verweis auf den Absatz abzurufen. Da die Elemente beginnend mit 0 (null) indiziert werden, übergeben Sie eine 0 (null), um den Verweis auf den ersten Absatz abrufen, wie im folgenden Beispiel gezeigt wird.

// Get the first paragraph in the document.
Paragraph? paragraph = doc?.MainDocumentPart?.Document?.Body?.Descendants<Paragraph>().ElementAtOrDefault(0);

Der Verweis auf den gefundenen Absatz wird in einer Variablen namens paragraph gespeichert. Wenn am angegebenen Index kein Absatz gefunden wird, gibt die ElementAtOrDefault Methode NULL als Standardwert zurück. Dies bietet die Möglichkeit, auf NULL zu testen und einen Fehler mit einer entsprechenden Fehlermeldung auszulösen.

Sobald Sie über die Verweise auf das Dokument und den Absatz verfügen, können Sie die ApplyStyleToParagraph Beispielmethode aufrufen, um die restliche Arbeit zu erledigen. Zum Aufrufen der Methode übergeben Sie den Verweis auf das Dokument als ersten Parameter, die Formatvorlagen-ID der anzuwendenden Formatvorlage als zweiten Parameter, den Namen der Formatvorlage als dritten Parameter und den Verweis auf den Absatz, auf den die Formatvorlage angewendet werden soll, als vierten Parameter.

Hinzufügen des Absatzeigenschaftenelements

Der erste Schritt der Beispielmethode besteht im Sicherstellen, dass der Absatz ein Absatzeigenschaftenelement enthält. Das Absatzeigenschaftenelement ist ein untergeordnetes Element des Absatzes und enthält eine Reihe von Eigenschaften, mit denen Sie die Formatierung des Absatzes angeben.

Die folgenden Informationen aus der SPEZIFIKATION ISO/IEC 29500 führen das pPr Element (Absatzeigenschaften) ein, das zum Angeben der Formatierung eines Absatzes verwendet wird. Beachten Sie, dass alle Abschnittsnummern, denen ein § vorangestellt ist, aus der ISO-Spezifikation stammen.

Innerhalb des Absatzes werden alle umfangreichen Formatierungen auf Absatzebene im pPr Element gespeichert (§17.3.1.25; §17.3.1.26). [Hinweis: Bei einigen Beispielen für Absatzeigenschaften handelt es sich um Ausrichtung, Rahmen, Außerkraftsetzung der Silbentrennung, Einzug, Zeilenabstand, Schattierung, Textrichtung und Steuerelemente für Absatzkontrolle.

Zu den Eigenschaften gehört das pStyle -Element, mit dem die Formatvorlage angegeben wird, die auf den Absatz angewendet werden soll. Das folgende Beispielmarkup zeigt beispielsweise ein pStyle-Element, das die Formatvorlage "OverdueAmount" angibt.

    <w:p  xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
      <w:pPr>
        <w:pStyle w:val="OverdueAmount" />
      </w:pPr>
      ... 
    </w:p>

Im Open XML SDK wird das pPr -Element durch die ParagraphProperties -Klasse dargestellt. Der Code bestimmt, ob das Element vorhanden ist, und erstellt eine neue instance der ParagraphProperties -Klasse, wenn dies nicht der Fall ist. Das pPr Element ist ein untergeordnetes Element des p (Absatz)-Elements. Daher wird die PrependChild -Methode verwendet, um die instance hinzuzufügen, wie im folgenden Codebeispiel gezeigt.

// If the paragraph has no ParagraphProperties object, create one.
if (p.Elements<ParagraphProperties>().Count() == 0)
{
    p.PrependChild<ParagraphProperties>(new ParagraphProperties());
}

// Get the paragraph properties element of the paragraph.
ParagraphProperties pPr = p.Elements<ParagraphProperties>().First();

Hinzufügen des Teils "Formatvorlagen"

Wenn der gefundene Absatz und das Absatzeigenschaftenelement vorhanden sind, stellen Sie jetzt sicher, dass die Voraussetzungen für die Anwendung der Formatvorlage erfüllt sind. Formatvorlagen in WordprocessingML werden in einem eigenen eindeutigen Teil gespeichert. Obwohl es in der Regel richtig ist, dass sowohl der Teil als auch eine Reihe von Basisformatvorlagen automatisch erstellt werden, wenn Sie das Dokument mithilfe einer Anwendung wie Microsoft Word erstellen, ist der Formatvorlagenteil nicht erforderlich, damit ein Dokument als gültig angesehen wird. Wenn Sie das Dokument programmgesteuert mit dem Open XML SDK erstellen, wird der Formatvorlagenteil nicht automatisch erstellt. sie müssen explizit erstellt werden. Folglich überprüft der folgende Code, ob der Formatvorlagenteil vorhanden ist, und erstellt ihn, wenn dies nicht der Fall ist.

// Get the Styles part for this document.
StyleDefinitionsPart? part = doc.MainDocumentPart?.StyleDefinitionsPart;

// If the Styles part does not exist, add it and then add the style.
if (part is null)
{
    part = AddStylesPartToPackage(doc);

Die AddStylesPartToPackage Beispielmethode führt das Hinzufügen des Stilteils durch. Er erstellt einen Teil des StyleDefinitionsPart Typs und fügt ihn dem Standard Dokumentteil als untergeordnetes Element hinzu. Der Code fügt dann das Styles Stammelement an, das das übergeordnete Element ist, das alle Stile enthält. Das Styles -Element wird durch die Styles -Klasse im Open XML SDK dargestellt. Abschließend speichert der Code den Teil.

// Add a StylesDefinitionsPart to the document.  Returns a reference to it.
static StyleDefinitionsPart AddStylesPartToPackage(WordprocessingDocument doc)
{
    MainDocumentPart mainDocumentPart = doc.MainDocumentPart ?? doc.AddMainDocumentPart();
    StyleDefinitionsPart part = mainDocumentPart.AddNewPart<StyleDefinitionsPart>();
    Styles root = new Styles();

    return part;
}

Überprüfen, ob die Formatvorlage vorhanden ist

Das Anwenden einer Formatvorlage, die nicht vorhanden ist, auf einen Absatz hat keine Auswirkungen. es wird keine Ausnahme generiert, und es treten keine Formatierungsänderungen auf. Der Beispielcode überprüft, ob die Formatvorlage vorhanden ist, bevor versucht wird, die Formatvorlage anzuwenden. Formatvorlagen werden im Formatvorlagenteil gespeichert. Wenn der Formatvorlagenteil also nicht vorhanden ist, kann die Formatvorlage selbst nicht vorhanden sein.

Wenn der Formatvorlagenteil vorhanden ist, überprüft der Code eine übereinstimmende Formatvorlage, indem er die IsStyleIdInDocument Beispielmethode aufruft und das Dokument und die styleid übergibt. Wenn keine Übereinstimmung für styleid gefunden wird, versucht der Code, die styleid zu suchen, indem die GetStyleIdFromStyleName Beispielmethode aufgerufen und ihr der Formatvorlagenname übergeben wird.

Wenn die Formatvorlage nicht vorhanden ist, weil der Formatvorlagenteil nicht vorhanden war oder weil der Formatvorlagenteil vorhanden ist, die Formatvorlage aber nicht, ruft der Code die AddNewStyle Beispielmethode auf, um die Formatvorlage hinzuzufügen.


// Get the Styles part for this document.
StyleDefinitionsPart? part = doc.MainDocumentPart?.StyleDefinitionsPart;

// If the Styles part does not exist, add it and then add the style.
if (part is null)
{
    part = AddStylesPartToPackage(doc);
    AddNewStyle(part, styleid, stylename);
}
else
{
    // If the style is not in the document, add it.
    if (IsStyleIdInDocument(doc, styleid) != true)
    {
        // No match on styleid, so let's try style name.
        string? styleidFromName = GetStyleIdFromStyleName(doc, stylename);

        if (styleidFromName is null)
        {
            AddNewStyle(part, styleid, stylename);
        }
        else
            styleid = styleidFromName;
    }
}

Innerhalb der IsStyleInDocument Beispielmethode beginnt die Arbeit damit, das Element über die StylesStyles -Eigenschaft des StyleDefinitionsPart Standard Dokumentteils abzurufen und dann zu bestimmen, ob Formatvorlagen als untergeordnete Elemente dieses Elements vorhanden sind. Alle Formatvorlagenelemente werden als untergeordnete Elemente des Formatvorlagenelements gespeichert.

Wenn Formatvorlagen vorhanden sind, sucht der Code nach einer Übereinstimmung für die styleid. Die styleid ist ein Attribut der Formatvorlage, das an vielen Stellen im Dokument verwendet wird, um auf die Formatvorlage zu verweisen, und kann als primärer Bezeichner betrachtet werden. In der Regel verwenden Sie die Formatvorlagen-ID, um eine Formatvorlage im Code zu identifizieren. Die FirstOrDefault -Methode ist standardmäßig auf NULL festgelegt, wenn keine Übereinstimmung gefunden wird, sodass der Code überprüft, ob eine Formatvorlage übereinstimmt, wie im folgenden Auszug gezeigt.

// Return true if the style id is in the document, false otherwise.
static bool IsStyleIdInDocument(WordprocessingDocument doc, string styleid)
{
    // Get access to the Styles element for this document.
    Styles? s = doc.MainDocumentPart?.StyleDefinitionsPart?.Styles;

    if (s is null)
    {
        return false;
    }

    // Check that there are styles and how many.
    int n = s.Elements<Style>().Count();

    if (n == 0)
    {
        return false;
    }

    // Look for a match on styleid.
    Style? style = s.Elements<Style>()
        .Where(st => (st.StyleId is not null && st.StyleId == styleid) && (st.Type is not null && st.Type == StyleValues.Paragraph))
        .FirstOrDefault();
    if (style is null)
    {
        return false;
    }

    return true;
}

Wenn die Formatvorlage nicht basierend auf der styleid gefunden werden kann, versucht der Code stattdessen, eine Übereinstimmung basierend auf dem Formatvorlagennamen zu finden. Die GetStyleIdFromStyleName Beispielmethode führt diese Arbeit aus: Sie sucht nach einer Übereinstimmung für den Formatvorlagennamen und gibt die Styleid für das übereinstimmende Element zurück, falls gefunden, oder null, wenn nicht.

Hinzufügen der Formatvorlage zum Formatvorlagenteil

Die AddNewStyle Beispielmethode akzeptiert drei Parameter. Der erste Parameter enthält einen Verweis auf den Formatvorlagenteil. Der zweite Parameter enthält die Formatvorlagen-ID der Formatvorlage und der dritte Parameter enthält den Formatvorlagennamen. Der AddNewStyle Code erstellt die benannte Formatvorlagendefinition innerhalb des angegebenen Teils.

Um die Formatvorlage zu erstellen, instanziiert der Code die Style -Klasse und legt bestimmte Eigenschaften fest, z. B. die der Type Formatvorlage (Absatz) und StyleId. Wie bereits erwähnt wird die Formatvorlagen-ID vom Dokument verwendet, um auf die Formatvorlage zu verweisen, und kann als primärer Bezeichner betrachtet werden. In der Regel verwenden Sie die Formatvorlagen-ID, um eine Formatvorlage im Code zu identifizieren. Eine Formatvorlage kann auch einen separaten Anzeigenamen haben, der auf der Benutzeroberfläche angezeigt wird. Häufig wird der Formatvorlagenname daher unter Beachtung von Groß-/Kleinschreibung und mit Leerzeichen (z. B. "Überschrift 1") angezeigt, während die Formatvorlagen-ID kurz gehalten (z. B. "überschrift1") und nur für die interne Verwendung vorgesehen ist. Im folgenden Beispielcode werden die Werte für die Formatvorlagen-ID und den Formatvorlagennamen aus den Parametern der Formatvorlagen-ID und des Formatvorlagennamens übernommen.

Der nächste Schritt besteht im Angeben einiger zusätzlicher Eigenschaften wie der Formatvorlage, auf der die neue Formatvorlage basiert, und der automatisch auf den nächsten Absatz anzuwendenden Formatvorlage. Im Code werden beide als Formatvorlage "Normal" angegeben. Beachten Sie, dass der hier anzugebende Wert die Formatvorlagen-ID für die Formatvorlage "Normal" ist. Der Code fügt diese Eigenschaften als untergeordnete Elemente des Formatvorlagenelements an.

Nachdem der Code die Formatvorlage instanziiert und die grundlegenden Eigenschaften eingerichtet hat, arbeiten Sie nun an der Formatvorlagenformatierung. Formatvorlagenformatierung wird in den Elementen absatzeigenschaften (pPr) und ausführungseigenschaften (rPr) ausgeführt. Um die Schriftart und Farbe für die Läufe in einem Absatz festzulegen, müssen Sie die Laufeigenschaften verwenden.

Um das rPr Element mit den entsprechenden untergeordneten Elementen zu erstellen, erstellt der Code eine instance der StyleRunProperties -Klasse und fügt dann Instanzen der entsprechenden Eigenschaftenklassen an. In diesem Codebeispiel gibt die Formatvorlage die Schriftart "Lucida Console" mit Schriftgrad 12 sowie fetter und kursiver Darstellung und die Verwendung der Farbe "Accent2" aus dem Dokumentdesignteil an. Der Schriftgrad ist in halben Punkten angegeben, sodass der Wert 24 den 12 Punkten entspricht.

Wenn die Formatvorlagendefinition abgeschlossen ist, fügt der Code die Formatvorlage an das Formatvorlagenelement im Formatvorlagenteil an, wie im folgenden Codebeispiel dargestellt ist.

// Create a new style with the specified styleid and stylename and add it to the specified
// style definitions part.
static void AddNewStyle(StyleDefinitionsPart styleDefinitionsPart, string styleid, string stylename)
{
    // Get access to the root element of the styles part.
    styleDefinitionsPart.Styles ??= new Styles();
    Styles styles = styleDefinitionsPart.Styles;

    // Create a new paragraph style and specify some of the properties.
    Style style = new Style()
    {
        Type = StyleValues.Paragraph,
        StyleId = styleid,
        CustomStyle = true
    };
    StyleName styleName1 = new StyleName() { Val = stylename };
    BasedOn basedOn1 = new BasedOn() { Val = "Normal" };
    NextParagraphStyle nextParagraphStyle1 = new NextParagraphStyle() { Val = "Normal" };
    style.Append(styleName1);
    style.Append(basedOn1);
    style.Append(nextParagraphStyle1);

    // Create the StyleRunProperties object and specify some of the run properties.
    StyleRunProperties styleRunProperties1 = new StyleRunProperties();
    Bold bold1 = new Bold();
    Color color1 = new Color() { ThemeColor = ThemeColorValues.Accent2 };
    RunFonts font1 = new RunFonts() { Ascii = "Lucida Console" };
    Italic italic1 = new Italic();
    // Specify a 12 point size.
    FontSize fontSize1 = new FontSize() { Val = "24" };
    styleRunProperties1.Append(bold1);
    styleRunProperties1.Append(color1);
    styleRunProperties1.Append(font1);
    styleRunProperties1.Append(fontSize1);
    styleRunProperties1.Append(italic1);

    // Add the run properties to the style.
    style.Append(styleRunProperties1);

    // Add the style to the styles part.
    styles.Append(style);
}

Beispielcode

Es folgt der vollständige Beispielcode in C# und Visual Basic.

using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
using System;
using System.Linq;

using (WordprocessingDocument doc = WordprocessingDocument.Open(args[0], true))
{
    // Get the first paragraph in the document.
    Paragraph? paragraph = doc?.MainDocumentPart?.Document?.Body?.Descendants<Paragraph>().ElementAtOrDefault(0);

    if (paragraph is not null)
    {
        ApplyStyleToParagraph(doc!, "MyStyle", "MyStyleName", paragraph);
    }
}


// Apply a style to a paragraph.
static void ApplyStyleToParagraph(WordprocessingDocument doc, string styleid, string stylename, Paragraph p)
{
    if (doc is null)
    {
        throw new ArgumentNullException(nameof(doc));
    }

    // If the paragraph has no ParagraphProperties object, create one.
    if (p.Elements<ParagraphProperties>().Count() == 0)
    {
        p.PrependChild<ParagraphProperties>(new ParagraphProperties());
    }

    // Get the paragraph properties element of the paragraph.
    ParagraphProperties pPr = p.Elements<ParagraphProperties>().First();


    // Get the Styles part for this document.
    StyleDefinitionsPart? part = doc.MainDocumentPart?.StyleDefinitionsPart;

    // If the Styles part does not exist, add it and then add the style.
    if (part is null)
    {
        part = AddStylesPartToPackage(doc);
        AddNewStyle(part, styleid, stylename);
    }
    else
    {
        // If the style is not in the document, add it.
        if (IsStyleIdInDocument(doc, styleid) != true)
        {
            // No match on styleid, so let's try style name.
            string? styleidFromName = GetStyleIdFromStyleName(doc, stylename);

            if (styleidFromName is null)
            {
                AddNewStyle(part, styleid, stylename);
            }
            else
                styleid = styleidFromName;
        }
    }

    // Set the style of the paragraph.
    pPr.ParagraphStyleId = new ParagraphStyleId() { Val = styleid };
}

// Return true if the style id is in the document, false otherwise.
static bool IsStyleIdInDocument(WordprocessingDocument doc, string styleid)
{
    // Get access to the Styles element for this document.
    Styles? s = doc.MainDocumentPart?.StyleDefinitionsPart?.Styles;

    if (s is null)
    {
        return false;
    }

    // Check that there are styles and how many.
    int n = s.Elements<Style>().Count();

    if (n == 0)
    {
        return false;
    }

    // Look for a match on styleid.
    Style? style = s.Elements<Style>()
        .Where(st => (st.StyleId is not null && st.StyleId == styleid) && (st.Type is not null && st.Type == StyleValues.Paragraph))
        .FirstOrDefault();
    if (style is null)
    {
        return false;
    }

    return true;
}

// Return styleid that matches the styleName, or null when there's no match.
static string? GetStyleIdFromStyleName(WordprocessingDocument doc, string styleName)
{
    StyleDefinitionsPart? stylePart = doc.MainDocumentPart?.StyleDefinitionsPart;
    string? styleId = stylePart?.Styles?.Descendants<StyleName>()
        .Where(s =>
        {
            OpenXmlElement? p = s.Parent;
            EnumValue<StyleValues>? styleValue = p is null ? null : ((Style)p).Type;

            return s.Val is not null && s.Val.Value is not null && s.Val.Value.Equals(styleName) &&
            (styleValue is not null && styleValue == StyleValues.Paragraph);
        })
        .Select(n =>
        {

            OpenXmlElement? p = n.Parent;
            return p is null ? null : ((Style)p).StyleId;
        }).FirstOrDefault();

    return styleId;
}

// Create a new style with the specified styleid and stylename and add it to the specified
// style definitions part.
static void AddNewStyle(StyleDefinitionsPart styleDefinitionsPart, string styleid, string stylename)
{
    // Get access to the root element of the styles part.
    styleDefinitionsPart.Styles ??= new Styles();
    Styles styles = styleDefinitionsPart.Styles;

    // Create a new paragraph style and specify some of the properties.
    Style style = new Style()
    {
        Type = StyleValues.Paragraph,
        StyleId = styleid,
        CustomStyle = true
    };
    StyleName styleName1 = new StyleName() { Val = stylename };
    BasedOn basedOn1 = new BasedOn() { Val = "Normal" };
    NextParagraphStyle nextParagraphStyle1 = new NextParagraphStyle() { Val = "Normal" };
    style.Append(styleName1);
    style.Append(basedOn1);
    style.Append(nextParagraphStyle1);

    // Create the StyleRunProperties object and specify some of the run properties.
    StyleRunProperties styleRunProperties1 = new StyleRunProperties();
    Bold bold1 = new Bold();
    Color color1 = new Color() { ThemeColor = ThemeColorValues.Accent2 };
    RunFonts font1 = new RunFonts() { Ascii = "Lucida Console" };
    Italic italic1 = new Italic();
    // Specify a 12 point size.
    FontSize fontSize1 = new FontSize() { Val = "24" };
    styleRunProperties1.Append(bold1);
    styleRunProperties1.Append(color1);
    styleRunProperties1.Append(font1);
    styleRunProperties1.Append(fontSize1);
    styleRunProperties1.Append(italic1);

    // Add the run properties to the style.
    style.Append(styleRunProperties1);

    // Add the style to the styles part.
    styles.Append(style);
}

// Add a StylesDefinitionsPart to the document.  Returns a reference to it.
static StyleDefinitionsPart AddStylesPartToPackage(WordprocessingDocument doc)
{
    MainDocumentPart mainDocumentPart = doc.MainDocumentPart ?? doc.AddMainDocumentPart();
    StyleDefinitionsPart part = mainDocumentPart.AddNewPart<StyleDefinitionsPart>();
    Styles root = new Styles();

    return part;
}