BuildingBlock

BuildingBlock class

Représente une entrée de document de glossaire telle qu’un bloc de construction, un texte automatique ou une entrée de correction automatique.

Pour en savoir plus, visitez leModèle d’objet de document (DOM) Aspose.Words article de documentation.

public class BuildingBlock : CompositeNode

Constructeurs

Nom	La description
BuildingBlock(GlossaryDocument)	Initialise une nouvelle instance de cette classe.

Propriétés

Nom	La description
Behavior { get; set; }	Spécifie le comportement qui doit être appliqué lorsque le contenu du bloc de construction est inséré dans le document principal.
Category { get; set; }	Spécifie la catégorisation de deuxième niveau pour le bloc de construction.
Count { get; }	Obtient le nombre d’enfants immédiats de ce nœud.
CustomNodeId { get; set; }	Spécifie l’identifiant de nœud personnalisé.
Description { get; set; }	Obtient ou définit la description associée à ce bloc de construction.
virtual Document { get; }	Obtient le document auquel appartient ce nœud.
FirstChild { get; }	Obtient le premier enfant du nœud.
FirstSection { get; }	Obtient la première section du bloc de construction.
Gallery { get; set; }	Spécifie la catégorisation de premier niveau pour le bloc de construction à des fins de classification ou de tri de l’interface utilisateur.
Guid { get; set; }	Obtient ou définit un identifiant (un GUID 128 bits) qui identifie de manière unique ce bloc de construction.
HasChildNodes { get; }	Retours`vrai` si ce nœud a des nœuds enfants.
override IsComposite { get; }	Retours`vrai` car ce nœud peut avoir des nœuds enfants.
LastChild { get; }	Obtient le dernier enfant du nœud.
LastSection { get; }	Obtient la dernière section du bloc de construction.
Name { get; set; }	Obtient ou définit le nom de ce bloc de construction.
NextSibling { get; }	Obtient le nœud suivant immédiatement ce nœud.
override NodeType { get; }	Renvoie leBuildingBlock valeur.
ParentNode { get; }	Obtient le parent immédiat de ce nœud.
PreviousSibling { get; }	Obtient le nœud précédant immédiatement ce nœud.
Range { get; }	Renvoie un`Range`objet qui représente la partie d’un document contenue dans ce nœud.
Sections { get; }	Renvoie une collection qui représente toutes les sections du bloc de construction.
Type { get; set; }	Spécifie le type de bloc de construction.

Méthodes

Nom	La description
override Accept(DocumentVisitor)	Accepte un visiteur.
override AcceptEnd(DocumentVisitor)	Accepte un visiteur pour visiter la fin du BuildingBlock.
override AcceptStart(DocumentVisitor)	Accepte un visiteur pour visiter le début du BuildingBlock.
AppendChild<T>(T)	Ajoute le nœud spécifié à la fin de la liste des nœuds enfants pour ce nœud.
Clone(bool)	Crée un doublon du nœud.
CreateNavigator()	Crée un navigateur qui peut être utilisé pour parcourir et lire les nœuds.
GetAncestor(NodeType)	Obtient le premier ancêtre du spécifié`NodeType` .
GetAncestor(Type)	Obtient le premier ancêtre du type d’objet spécifié.
GetChild(NodeType, int, bool)	Renvoie un Nième nœud enfant qui correspond au type spécifié.
GetChildNodes(NodeType, bool)	Renvoie une collection active de nœuds enfants qui correspondent au type spécifié.
GetEnumerator()	Fournit un support pour chaque itération de style sur les nœuds enfants de ce nœud.
override GetText()	Obtient le texte de ce nœud et de tous ses enfants.
IndexOf(Node)	Renvoie l’index du nœud enfant spécifié dans le tableau de nœuds enfants.
InsertAfter<T>(T, Node)	Insère le nœud spécifié immédiatement après le nœud de référence spécifié.
InsertBefore<T>(T, Node)	Insère le nœud spécifié immédiatement avant le nœud de référence spécifié.
NextPreOrder(Node)	Obtient le nœud suivant selon l’algorithme de parcours de l’arbre de pré-ordre.
PrependChild<T>(T)	Ajoute le nœud spécifié au début de la liste des nœuds enfants pour ce nœud.
PreviousPreOrder(Node)	Obtient le nœud précédent selon l’algorithme de parcours de l’arbre de pré-ordre.
Remove()	Se supprime du parent.
RemoveAllChildren()	Supprime tous les nœuds enfants du nœud actuel.
RemoveChild<T>(T)	Supprime le nœud enfant spécifié.
RemoveSmartTags()	Supprime tout`SmartTag` nœuds descendants du nœud actuel.
SelectNodes(string)	Sélectionne une liste de nœuds correspondant à l’expression XPath.
SelectSingleNode(string)	Sélectionne le premier`Node` qui correspond à l’expression XPath.
ToString(SaveFormat)	Exporte le contenu du nœud dans une chaîne au format spécifié.
ToString(SaveOptions)	Exporte le contenu du nœud dans une chaîne en utilisant les options de sauvegarde spécifiées.

Remarques

BuildingBlock ne peut contenir queSection nœuds.

BuildingBlock ne peut être qu’un enfant deGlossaryDocument.

Vous pouvez créer de nouveaux blocs de construction et les insérer dans un document de glossaire. Vous pouvez modifier ou supprimer des blocs de construction existants. Vous pouvez copier ou déplacer des blocs de construction entre des documents. Vous pouvez insérer le contenu d’un bloc de construction dans un document.

Correspond à ladocPart ,docPartPr etdocPartBodyéléments dans OOXML.

Exemples

Montre comment ajouter un bloc de construction personnalisé à un document.

public void CreateAndInsert()
{
    // Le glossaire d'un document stocke les blocs de construction.
    Document doc = new Document();
    GlossaryDocument glossaryDoc = new GlossaryDocument();
    doc.GlossaryDocument = glossaryDoc;

    // Créez un bloc de construction, nommez-le, puis ajoutez-le au document de glossaire.
    BuildingBlock block = new BuildingBlock(glossaryDoc)
    {
        Name = "Custom Block"
    };

    glossaryDoc.AppendChild(block);

    // Tous les nouveaux GUID de blocs de construction ont la même valeur zéro par défaut, et nous pouvons leur donner une nouvelle valeur unique.
    Assert.AreEqual("00000000-0000-0000-0000-000000000000", block.Guid.ToString());

    block.Guid = Guid.NewGuid();

    // Les propriétés suivantes catégorisent les blocs de construction
    // dans le menu auquel nous pouvons accéder dans Microsoft Word via "Insertion" -> "Parties rapides" -> "Organisateur de blocs de construction".
    Assert.AreEqual("(Empty Category)", block.Category);
    Assert.AreEqual(BuildingBlockType.None, block.Type);
    Assert.AreEqual(BuildingBlockGallery.All, block.Gallery);
    Assert.AreEqual(BuildingBlockBehavior.Content, block.Behavior);

    // Avant de pouvoir ajouter ce bloc de construction à notre document, nous devrons lui donner du contenu,
    // que nous réaliserons à l'aide d'un visiteur de document. Ce visiteur définira également une catégorie, une galerie et un comportement.
    BuildingBlockVisitor visitor = new BuildingBlockVisitor(glossaryDoc);
    // Visitez le début/la fin du BuildingBlock.
    block.Accept(visitor);

    // Nous pouvons accéder au bloc que nous venons de créer à partir du document glossaire.
    BuildingBlock customBlock = glossaryDoc.GetBuildingBlock(BuildingBlockGallery.QuickParts,
        "My custom building blocks", "Custom Block");

    // Le bloc lui-même est une section qui contient le texte.
    Assert.AreEqual($"Text inside {customBlock.Name}\f", customBlock.FirstSection.Body.FirstParagraph.GetText());
    Assert.AreEqual(customBlock.FirstSection, customBlock.LastSection);
    // Maintenant, nous pouvons l'insérer dans le document en tant que nouvelle section.
    doc.AppendChild(doc.ImportNode(customBlock.FirstSection, true));

    // Nous pouvons également le trouver dans l'organisateur de blocs de construction de Microsoft Word et le placer manuellement.
    doc.Save(ArtifactsDir + "BuildingBlocks.CreateAndInsert.dotx");
}

/// <summary>
/// Configure un bloc de construction visité à insérer dans le document en tant que partie rapide et ajoute du texte à son contenu.
/// </summary>
public class BuildingBlockVisitor : DocumentVisitor
{
    public BuildingBlockVisitor(GlossaryDocument ownerGlossaryDoc)
    {
        mBuilder = new StringBuilder();
        mGlossaryDoc = ownerGlossaryDoc;
    }

    public override VisitorAction VisitBuildingBlockStart(BuildingBlock block)
    {
        // Configurez le bloc de construction en tant que partie rapide et ajoutez les propriétés utilisées par Building Blocks Organizer.
        block.Behavior = BuildingBlockBehavior.Paragraph;
        block.Category = "My custom building blocks";
        block.Description =
            "Using this block in the Quick Parts section of word will place its contents at the cursor.";
        block.Gallery = BuildingBlockGallery.QuickParts;

        // Ajouter une section avec du texte.
        // L'insertion du bloc dans le document ajoutera cette section avec ses nœuds enfants à l'emplacement.
        Section section = new Section(mGlossaryDoc);
        block.AppendChild(section);
        block.FirstSection.EnsureMinimum();

        Run run = new Run(mGlossaryDoc, "Text inside " + block.Name);
        block.FirstSection.Body.FirstParagraph.AppendChild(run);

        return VisitorAction.Continue;
    }

    public override VisitorAction VisitBuildingBlockEnd(BuildingBlock block)
    {
        mBuilder.Append("Visited " + block.Name + "\r\n");
        return VisitorAction.Continue;
    }

    private readonly StringBuilder mBuilder;
    private readonly GlossaryDocument mGlossaryDoc;
}

Voir également

class CompositeNode
espace de noms Aspose.Words.BuildingBlocks
Assemblée Aspose.Words

BuildingBlockBehavior Enum