FieldStart

FieldStart class

Représente le début d’un champ Word dans un document.

Pour en savoir plus, visitez leTravailler avec des champs article documentaire.

public class FieldStart : FieldChar

Propriétés

Nom	La description
CustomNodeId { get; set; }	Spécifie l’identifiant de nœud personnalisé.
virtual Document { get; }	Obtient le document auquel appartient ce nœud.
FieldData { get; }	Obtient les données de champ personnalisées associées au champ.
FieldType { get; }	Renvoie le type du champ.
Font { get; }	Donne accès au formatage de la police de cet objet.
virtual IsComposite { get; }	Retoursvrai si ce nœud peut contenir d’autres nœuds.
IsDeleteRevision { get; }	Renvoie vrai si cet objet a été supprimé dans Microsoft Word alors que le suivi des modifications était activé.
IsDirty { get; set; }	Obtient ou définit si le résultat actuel du champ n’est plus correct (périmé) en raison d’autres modifications apportées au document.
IsFormatRevision { get; }	Renvoie vrai si le formatage de l’objet a été modifié dans Microsoft Word alors que le suivi des modifications était activé.
IsInsertRevision { get; }	Renvoie vrai si cet objet a été inséré dans Microsoft Word alors que le suivi des modifications était activé.
IsLocked { get; set; }	Obtient ou définit si le champ parent est verrouillé (ne doit pas recalculer son résultat).
IsMoveFromRevision { get; }	Retoursvrai si cet objet a été déplacé (supprimé) dans Microsoft Word alors que le suivi des modifications était activé.
IsMoveToRevision { get; }	Retoursvrai si cet objet a été déplacé (inséré) dans Microsoft Word alors que le suivi des modifications était activé.
NextSibling { get; }	Obtient le nœud suivant immédiatement ce nœud.
override NodeType { get; }	RetoursFieldStart .
ParentNode { get; }	Obtient le parent immédiat de ce nœud.
ParentParagraph { get; }	Récupère le parentParagraph de ce nœud.
PreviousSibling { get; }	Obtient le nœud précédant immédiatement ce nœud.
Range { get; }	Renvoie unRange objet qui représente la partie d’un document contenue dans ce nœud.

Méthodes

Nom	La description
override Accept(DocumentVisitor)	Accepte un visiteur.
Clone(bool)	Crée un duplicata du nœud.
GetAncestor(NodeType)	Obtient le premier ancêtre du spécifiéNodeType .
GetAncestor(Type)	Obtient le premier ancêtre du type d’objet spécifié.
GetField()	Renvoie un champ pour le champ char.
override GetText()	Obtient le caractère spécial que représente ce nœud.
NextPreOrder(Node)	Obtient le nœud suivant selon l’algorithme de traversée de l’arbre de pré-commande.
PreviousPreOrder(Node)	Obtient le nœud précédent selon l’algorithme de traversée d’arbre de pré-commande.
Remove()	Se supprime du parent.
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 à l’aide des options de sauvegarde spécifiées.

Remarques

FieldStart est un nœud de niveau en ligne et représenté par the FieldStartChar caractère de contrôle dans le document.

FieldStart ne peut être qu’un enfant deParagraph.

Un champ complet dans un document Microsoft Word est une structure complexe composée de , d’un caractère de début de champ, d’un code de champ, d’un caractère séparateur de champ, d’un résultat de champ et d’un caractère de fin de champ. Certains champs n’ont qu’un début de champ, un code de champ et une fin de champ.

Pour insérer facilement un nouveau champ dans un document, utilisez leInsertField Méthode .

Exemples

Montre comment travailler avec une collection de champs.

public void FieldCollection()
{
    Document doc = new Document();
    DocumentBuilder builder = new DocumentBuilder(doc);

    builder.InsertField(" DATE \\@ \"dddd, d MMMM yyyy\" ");
    builder.InsertField(" TIME ");
    builder.InsertField(" REVNUM ");
    builder.InsertField(" AUTHOR  \"John Doe\" ");
    builder.InsertField(" SUBJECT \"My Subject\" ");
    builder.InsertField(" QUOTE \"Hello world!\" ");
    doc.UpdateFields();

    FieldCollection fields = doc.Range.Fields;

    Assert.AreEqual(6, fields.Count);

    // Parcourir la collection de champs, imprimer le contenu et le type
    // de chaque champ en utilisant une implémentation de visiteur personnalisée.
    FieldVisitor fieldVisitor = new FieldVisitor();

    using (IEnumerator<Field> fieldEnumerator = fields.GetEnumerator())
    {
        while (fieldEnumerator.MoveNext())
        {
            if (fieldEnumerator.Current != null)
            {
                fieldEnumerator.Current.Start.Accept(fieldVisitor);
                fieldEnumerator.Current.Separator?.Accept(fieldVisitor);
                fieldEnumerator.Current.End.Accept(fieldVisitor);
            }
            else
            {
                Console.WriteLine("There are no fields in the document.");
            }
        }
    }

    Console.WriteLine(fieldVisitor.GetText());
}

/// <summary>
/// Implémentation du visiteur du document qui imprime les informations sur le champ.
/// </summary>
public class FieldVisitor : DocumentVisitor
{
    public FieldVisitor()
    {
        mBuilder = new StringBuilder();
    }

    /// <summary>
    /// Obtient le texte brut du document accumulé par le visiteur.
    /// </summary>
    public string GetText()
    {
        return mBuilder.ToString();
    }

    /// <summary>
    /// Appelé lorsqu'un nœud FieldStart est rencontré dans le document.
    /// </summary>
    public override VisitorAction VisitFieldStart(FieldStart fieldStart)
    {
        mBuilder.AppendLine("Found field: " + fieldStart.FieldType);
        mBuilder.AppendLine("\tField code: " + fieldStart.GetField().GetFieldCode());
        mBuilder.AppendLine("\tDisplayed as: " + fieldStart.GetField().Result);

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Appelé lorsqu'un nœud FieldSeparator est rencontré dans le document.
    /// </summary>
    public override VisitorAction VisitFieldSeparator(FieldSeparator fieldSeparator)
    {
        mBuilder.AppendLine("\tFound separator: " + fieldSeparator.GetText());

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Appelé lorsqu'un nœud FieldEnd est rencontré dans le document.
    /// </summary>
    public override VisitorAction VisitFieldEnd(FieldEnd fieldEnd)
    {
        mBuilder.AppendLine("End of field: " + fieldEnd.FieldType);

        return VisitorAction.Continue;
    }

    private readonly StringBuilder mBuilder;
}

Montre comment rechercher tous les liens hypertexte dans un document Word, puis modifier leurs URL et leurs noms d’affichage.

using System;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using Aspose.Words;
using Aspose.Words.Fields;
using NUnit.Framework;

namespace ApiExamples
{
    public class ExReplaceHyperlinks : ApiExampleBase
    {
        public void Fields()
        {
            Document doc = new Document(MyDir + "Hyperlinks.docx");

            // Les hyperliens dans un document Word sont des champs. Pour commencer à chercher des hyperliens, il faut d’abord trouver tous les champs.
            // Utilisez la méthode "SelectNodes" pour retrouver tous les champs du document via un XPath.
            NodeList fieldStarts = doc.SelectNodes("//Début du champ");

            foreach (FieldStart fieldStart in fieldStarts.OfType<FieldStart>())
            {
                if (fieldStart.FieldType == FieldType.FieldHyperlink)
                {
                    Hyperlink hyperlink = new Hyperlink(fieldStart);

                    // Les hyperliens renvoyant vers des signets n'ont pas d'URL.
                    if (hyperlink.IsLocal)
                        continue;

                    // Attribue à chaque lien hypertexte URL une nouvelle URL et un nouveau nom.
                    hyperlink.Target = NewUrl;
                    hyperlink.Name = NewName;
                }
            }

            doc.Save(ArtifactsDir + "ReplaceHyperlinks.Fields.docx");
        }

        private const string NewUrl = @"http://www.aspose.com";
        private const string NewName = "Aspose - The .NET & Java Component Publisher";
    }

     ///<summary>
      ///Les champs HYPERLINK contiennent et affichent des hyperliens dans le corps du document. Un champ dans Aspose.Words
      ///se compose de plusieurs nœuds et il peut être difficile de travailler directement avec tous ces nœuds.
     ///Cette implémentation ne fonctionnera que si le code et le nom du lien hypertexte sont chacun constitués d'un seul nœud Run.
    ///
     ///La structure des nœuds pour les champs est la suivante :
     ///
     ///[FieldStart][Run - field code][FieldSeparator][Run - field result][FieldEnd]
     ///
     ///Below are two example field codes of HYPERLINK fields:
     ///HYPERLINK "url"
     ///HYPERLINK \l "bookmark name"
     ///
     ///A field's "Result" property contains text that the field displays in the document body to the user.
     ///</summary>
    internal class Hyperlink
    {
        internal Hyperlink(FieldStart fieldStart)
        {
            if (fieldStart == null)
                throw new ArgumentNullException("fieldStart");
            if (fieldStart.FieldType != FieldType.FieldHyperlink)
                throw new ArgumentException("Field start type must be FieldHyperlink.");

            mFieldStart = fieldStart;

            // Recherche le nœud séparateur de champ.
            mFieldSeparator = FindNextSibling(mFieldStart, NodeType.FieldSeparator);
            if (mFieldSeparator == null)
                throw new InvalidOperationException("Cannot find field separator.");

             // Normalement, on peut toujours trouver le nœud de fin du champ, mais le document exemple
             // contient un saut de paragraphe à l'intérieur d'un lien hypertexte, qui met le champ à la fin
            // dans le paragraphe suivant. Il sera beaucoup plus compliqué de gérer des champs qui s'étendent sur plusieurs
            // paragraphes correctement. Dans ce cas, il suffit de permettre à la fin du champ d'être nulle.
            mFieldEnd = FindNextSibling(mFieldSeparator, NodeType.FieldEnd);

            // Le code du champ ressemble à "HYPERLINK "http:\\www.myurl.com"", mais il peut être composé de plusieurs exécutions.
            string fieldCode = GetTextSameParent(mFieldStart.NextSibling, mFieldSeparator);
            Match match = gRegex.Match(fieldCode.Trim());

            // Le lien hypertexte est local si \l est présent dans le code du champ.
            mIsLocal = match.Groups[1].Length > 0; 
            mTarget = match.Groups[2].Value;
        }

         ///<summary>
         ///Gets or sets the display name of the hyperlink.
         ///</summary>
        internal string Name
        {
            get => GetTextSameParent(mFieldSeparator, mFieldEnd); 
            set
            {
                 // Le nom d'affichage du lien hypertexte est stocké dans le résultat du champ, qui est un Run
                // nœud entre le séparateur de champ et la fin du champ.
                Run fieldResult = (Run) mFieldSeparator.NextSibling;
                fieldResult.Text = value;

                // Si le résultat du champ comprend plusieurs exécutions, supprimez ces exécutions.
                RemoveSameParent(fieldResult.NextSibling, mFieldEnd);
            }
        }

         ///<summary>
         ///Gets or sets the target URL or bookmark name of the hyperlink.
         ///</summary>
        internal string Target
        {
            get => mTarget;
            set
            {
                mTarget = value;
                UpdateFieldCode();
            }
        }

         ///<summary>
         ///True if the hyperlinks target is a bookmark inside the document. False if the hyperlink is a URL.
         ///</summary>
        internal bool IsLocal
        {
            get => mIsLocal; 
            set
            {
                mIsLocal = value;
                UpdateFieldCode();
            }
        }

        private void UpdateFieldCode()
        {
            // Le code de champ d'un champ se trouve dans un nœud Exécuter entre le nœud de début du champ et le séparateur de champ.
            Run fieldCode = (Run) mFieldStart.NextSibling;
            fieldCode.Text = string.Format("HYPERLINK {0}\"{1}\"", ((mIsLocal) ? "\\l " : ""), mTarget);

            // Si le code de champ comprend plusieurs exécutions, supprimez ces exécutions.
            RemoveSameParent(fieldCode.NextSibling, mFieldSeparator);
        }

         ///<summary>
         ///Goes through siblings starting from the start node until it finds a node of the specified type or null.
         ///</summary>
        private static Node FindNextSibling(Node startNode, NodeType nodeType)
        {
            for (Node node = startNode; node != null; node = node.NextSibling)
            {
                if (node.NodeType == nodeType)
                    return node;
            }

            return null;
        }

         ///<summary>
         ///Retrieves text from start up to but not including the end node.
         ///</summary>
        private static string GetTextSameParent(Node startNode, Node endNode)
        {
            if ((endNode != null) && (startNode.ParentNode != endNode.ParentNode))
                throw new ArgumentException("Start and end nodes are expected to have the same parent.");

            StringBuilder builder = new StringBuilder();
            for (Node child = startNode; !child.Equals(endNode); child = child.NextSibling)
                builder.Append(child.GetText());

            return builder.ToString();
        }

         ///<summary>
         ///Removes nodes from start up to but not including the end node.
         ///Assumes that the start and end nodes have the same parent.
         ///</summary>
        private static void RemoveSameParent(Node startNode, Node endNode)
        {
            if (endNode != null && startNode.ParentNode != endNode.ParentNode)
                throw new ArgumentException("Start and end nodes are expected to have the same parent.");

            Node curChild = startNode;
            while ((curChild != null) && (curChild != endNode))
            {
                Node nextChild = curChild.NextSibling;
                curChild.Remove();
                curChild = nextChild;
            }
        }

        private readonly Node mFieldStart;
        private readonly Node mFieldSeparator;
        private readonly Node mFieldEnd;
        private bool mIsLocal;
        private string mTarget;

        private static readonly Regex gRegex = new Regex(
            "\\S+" + // Un ou plusieurs HYPERLIEN sans espaces ou autre mot dans d'autres langues.
            "\\s+" + // Un ou plusieurs espaces.
            "(?:\"\"\\s+)?" + // Non-capture "" facultatif et un ou plusieurs espaces.
            "(\\\\l\\s+)?" + // Indicateur \l facultatif suivi d'un ou plusieurs espaces.
            "\"" +  // Une apostrophe.
            "([^\"]+)" + // Un ou plusieurs caractères, hors apostrophe (cible du lien hypertexte).
            "\"" // Une apostrophe fermante.
        );
    }
}

Voir également

• class FieldChar
• espace de noms Aspose.Words.Fields
• Assemblée Aspose.Words