FieldStart

FieldStart class

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

Pour en savoir plus, visitez leTravailler avec les champs article de documentation.

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 à la mise en forme 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 (obsolète) en raison d’autres modifications apportées au document.
IsFormatRevision { get; }	Renvoie true si la mise en forme de l’objet a été modifiée 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 unRangeobjet 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 doublon 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 ce nœud représente.
NextPreOrder(Node)	Obtient le nœud suivant selon l’algorithme de parcours de l’arbre de pré-ordre.
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.
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

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 d’un caractère de début, d’un code, d’un séparateur, d’un résultat et d’un caractère de fin. Certains champs ne comportent que le début, le code et la fin du 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);

    // Itérer sur la collection de champs et imprimer le contenu et le type
    // de chaque champ à l'aide d'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 de document qui imprime les informations du 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 hyperliens 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 rechercher des hyperliens, il faut d'abord trouver tous les champs.
            // Utilisez la méthode « SelectNodes » pour rechercher 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 qui renvoient vers des signets n'ont pas d'URL.
                    if (hyperlink.IsLocal)
                        continue;

                    // Donnez à 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 se composent chacun d'un seul nœud Exécuter.
    ///
     ///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;

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

             // Normalement, nous pouvons toujours trouver le nœud de fin du champ, mais le document d'exemple
             // contient un saut de paragraphe à l'intérieur d'un lien hypertexte, ce 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, autoriser la valeur null pour le champ end suffit.
            mFieldEnd = FindNextSibling(mFieldSeparator, NodeType.FieldEnd);

            // Le code du champ ressemble à quelque chose comme "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());

            // L'hyperlien 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
            {
                return GetTextSameParent(mFieldSeparator, mFieldEnd);
            }
            set
            {
                 // Le nom d'affichage du lien hypertexte est stocké dans le champ résultat, qui est une exécution
                // 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 se compose de 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
            {
                return 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
            {
                return 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épart 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 se compose de 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 HYPERLINK ou autre mot non-espace dans d'autres langues.
            "\\s+" + // Un ou plusieurs espaces.
            "(?:\"\"\\s+)?" + // Facultatif non capturant "" et un ou plusieurs espaces.
            "(\\\\l\\s+)?" + // Indicateur facultatif \l suivi d'un ou plusieurs espaces.
            "\"" +  // Une apostrophe.
            "([^\"]+)" + // Un ou plusieurs caractères, à l'exclusion de l'apostrophe (cible du lien hypertexte).
            "\"" // Une apostrophe fermante.
        );
    }
}

Voir également

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