FieldStart

FieldStart class

Stellt den Anfang eines Word-Felds in einem Dokument dar.

Um mehr zu erfahren, besuchen Sie dieArbeiten mit Feldern Dokumentationsartikel.

public class FieldStart : FieldChar

Eigenschaften

Name	Beschreibung
CustomNodeId { get; set; }	Gibt die benutzerdefinierte Knotenkennung an.
virtual Document { get; }	Ruft das Dokument ab, zu dem dieser Knoten gehört.
FieldData { get; }	Ruft benutzerdefinierte Felddaten ab, die dem Feld zugeordnet sind.
FieldType { get; }	Gibt den Typ des Feldes zurück.
Font { get; }	Bietet Zugriff auf die Schriftartformatierung dieses Objekts.
virtual IsComposite { get; }	Gibt zurückWAHR ob dieser Knoten andere Knoten enthalten kann.
IsDeleteRevision { get; }	Gibt „true“ zurück, wenn dieses Objekt in Microsoft Word gelöscht wurde, während die Änderungsverfolgung aktiviert war.
IsDirty { get; set; }	Ruft ab oder legt fest, ob das aktuelle Ergebnis des Felds aufgrund anderer am Dokument vorgenommener Änderungen nicht mehr korrekt (veraltet) ist.
IsFormatRevision { get; }	Gibt „true“ zurück, wenn die Formatierung des Objekts in Microsoft Word geändert wurde, während die Änderungsverfolgung aktiviert war.
IsInsertRevision { get; }	Gibt „true“ zurück, wenn dieses Objekt in Microsoft Word eingefügt wurde, während die Änderungsverfolgung aktiviert war.
IsLocked { get; set; }	Ruft ab oder legt fest, ob das übergeordnete Feld gesperrt ist (sollte sein Ergebnis nicht neu berechnen).
IsMoveFromRevision { get; }	Gibt zurückWAHR wenn dieses Objekt in Microsoft Word verschoben (gelöscht) wurde, während die Änderungsverfolgung aktiviert war.
IsMoveToRevision { get; }	Gibt zurückWAHR wenn dieses Objekt in Microsoft Word verschoben (eingefügt) wurde, während die Änderungsverfolgung aktiviert war.
NextSibling { get; }	Ruft den Knoten ab, der diesem Knoten unmittelbar folgt.
override NodeType { get; }	Gibt zurückFieldStart .
ParentNode { get; }	Ruft das unmittelbare übergeordnete Element dieses Knotens ab.
ParentParagraph { get; }	Ruft das übergeordnete Element abParagraph dieses Knotens.
PreviousSibling { get; }	Ruft den Knoten ab, der diesem Knoten unmittelbar vorangeht.
Range { get; }	Gibt a zurückRange Objekt, das den Teil eines Dokuments darstellt, der in diesem Knoten enthalten ist.

Methoden

Name	Beschreibung
override Accept(DocumentVisitor)	Akzeptiert einen Besucher.
Clone(bool)	Erstellt ein Duplikat des Knotens.
GetAncestor(NodeType)	Ruft den ersten Vorfahren des angegebenen abNodeType .
GetAncestor(Type)	Ruft den ersten Vorfahren des angegebenen Objekttyps ab.
GetField()	Gibt ein Feld für das Feld char zurück.
override GetText()	Ruft das Sonderzeichen ab, das dieser Knoten darstellt.
NextPreOrder(Node)	Ruft den nächsten Knoten gemäß dem Pre-Order-Tree-Traversal-Algorithmus ab.
PreviousPreOrder(Node)	Ruft den vorherigen Knoten gemäß dem Pre-Order-Tree-Traversal-Algorithmus ab.
Remove()	Entfernt sich selbst vom übergeordneten Element.
ToString(SaveFormat)	Exportiert den Inhalt des Knotens in einen String im angegebenen Format.
ToString(SaveOptions)	Exportiert den Inhalt des Knotens mit den angegebenen Speicheroptionen in einen String.

Bemerkungen

FieldStart ist ein Knoten auf Inline-Ebene und wird durch the dargestellt.FieldStartChar Steuerzeichen im Dokument.

FieldStart kann nur ein Kind von seinParagraph.

Ein vollständiges Feld in einem Microsoft Word-Dokument ist eine komplexe Struktur, die aus einem Feldanfangszeichen, einem Feldcode, einem Feldtrennzeichen, einem Feldergebnis und einem Feldendzeichen besteht. Einige Felder verfügen nur über Feldanfang, Feldcode und Feldende.

Um ganz einfach ein neues Feld in ein Dokument einzufügen, verwenden Sie dieInsertField -Methode.

Beispiele

Zeigt, wie mit einer Sammlung von Feldern gearbeitet wird.

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);

    // Über die Feldsammlung iterieren und Inhalt und Typ ausgeben
    // jedes Feldes mithilfe einer benutzerdefinierten Besucherimplementierung.
    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>
/// Dokumentieren Sie die Besucherimplementierung, die Feldinformationen druckt.
/// </summary>
public class FieldVisitor : DocumentVisitor
{
    public FieldVisitor()
    {
        mBuilder = new StringBuilder();
    }

    /// <summary>
    /// Ruft den Klartext des vom Besucher gesammelten Dokuments ab.
    /// </summary>
    public string GetText()
    {
        return mBuilder.ToString();
    }

    /// <summary>
    /// Wird aufgerufen, wenn im Dokument ein FieldStart-Knoten gefunden wird.
    /// </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>
    /// Wird aufgerufen, wenn im Dokument ein FieldSeparator-Knoten gefunden wird.
    /// </summary>
    public override VisitorAction VisitFieldSeparator(FieldSeparator fieldSeparator)
    {
        mBuilder.AppendLine("\tFound separator: " + fieldSeparator.GetText());

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Wird aufgerufen, wenn im Dokument ein FieldEnd-Knoten gefunden wird.
    /// </summary>
    public override VisitorAction VisitFieldEnd(FieldEnd fieldEnd)
    {
        mBuilder.AppendLine("End of field: " + fieldEnd.FieldType);

        return VisitorAction.Continue;
    }

    private readonly StringBuilder mBuilder;
}

Zeigt, wie Sie alle Hyperlinks in einem Word-Dokument finden und dann ihre URLs und Anzeigenamen ändern.

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");

            // Hyperlinks in einem Word-Dokument sind Felder. Um mit der Suche nach Hyperlinks zu beginnen, müssen wir zunächst alle Felder finden.
            // Verwenden Sie die Methode „SelectNodes“, um alle Felder im Dokument über einen XPath zu finden.
            NodeList fieldStarts = doc.SelectNodes("//FieldStart");

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

                    // Hyperlinks, die auf Lesezeichen verweisen, haben keine URLs.
                    if (hyperlink.IsLocal)
                        continue;

                    // Geben Sie jedem URL-Hyperlink eine neue URL und einen neuen Namen.
                    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>
      ///HYPERLINK-Felder enthalten Hyperlinks im Dokumentkörper und zeigen diese an. Ein Feld in Aspose.Words
      ///besteht aus mehreren Knoten, und es könnte schwierig sein, mit allen diesen Knoten direkt zu arbeiten.
     ///Diese Implementierung funktioniert nur, wenn der Hyperlink-Code und der Name jeweils nur aus einem Run-Knoten bestehen.
    ///
     ///Die Knotenstruktur für Felder ist wie folgt:
     ///
     ///[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;

            // Den Feldtrennknoten finden.
            mFieldSeparator = FindNextSibling(mFieldStart, NodeType.FieldSeparator);
            if (mFieldSeparator == null)
                throw new InvalidOperationException("Cannot find field separator.");

             // Normalerweise können wir immer den Endknoten des Feldes finden, aber das Beispieldokument
             // enthält einen Absatzumbruch innerhalb eines Hyperlinks, der das Feldende setzt
            // im nächsten Absatz. Es wird viel komplizierter sein, Felder zu verwalten, die sich über mehrere Felder erstrecken
            // Absätze richtig. In diesem Fall reicht es aus, das Feldende auf Null zu setzen.
            mFieldEnd = FindNextSibling(mFieldSeparator, NodeType.FieldEnd);

            // Der Feldcode sieht etwa wie „HYPERLINK „http:\\www.myurl.com““ aus, kann aber aus mehreren Durchläufen bestehen.
            string fieldCode = GetTextSameParent(mFieldStart.NextSibling, mFieldSeparator);
            Match match = gRegex.Match(fieldCode.Trim());

            // Der Hyperlink ist lokal, wenn \l im Feldcode vorhanden ist.
            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
            {
                 // Der Anzeigename des Hyperlinks wird im Feldergebnis gespeichert, bei dem es sich um eine Ausführung handelt
                // Knoten zwischen Feldtrenner und Feldende.
                Run fieldResult = (Run) mFieldSeparator.NextSibling;
                fieldResult.Text = value;

                // Wenn das Feldergebnis aus mehr als einem Lauf besteht, löschen Sie diese Läufe.
                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()
        {
            // Der Feldcode eines Feldes befindet sich in einem Run-Knoten zwischen dem Startknoten des Feldes und dem Feldtrennzeichen.
            Run fieldCode = (Run) mFieldStart.NextSibling;
            fieldCode.Text = string.Format("HYPERLINK {0}\"{1}\"", ((mIsLocal) ? "\\l " : ""), mTarget);

            // Wenn der Feldcode aus mehr als einem Lauf besteht, löschen Sie diese Läufe.
            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+" + // Ein oder mehrere HYPERLINK-Zeichen, die keine Leerzeichen sind, oder ein anderes Wort in anderen Sprachen.
            "\\s+" + // Ein oder mehrere Leerzeichen.
            "(?:\"\"\\s+)?" + // Nicht erfassendes optionales „“ und ein oder mehrere Leerzeichen.
            "(\\\\l\\s+)?" + // Optionales \l-Flag, gefolgt von einem oder mehreren Leerzeichen.
            "\"" +  // Ein Apostroph.
            "([^\"]+)" + // Ein oder mehrere Zeichen, außer dem Apostroph (Hyperlink-Ziel).
            "\"" // Ein abschließendes Apostroph.
        );
    }
}

Siehe auch

• class FieldChar
• namensraum Aspose.Words.Fields
• Montage Aspose.Words