FieldStart

FieldStart class

Representa el inicio de un campo de Word en un documento.

Para obtener más información, visite elTrabajar con campos Artículo de documentación.

public class FieldStart : FieldChar

Propiedades

Nombre	Descripción
CustomNodeId { get; set; }	Especifica un identificador de nodo personalizado.
virtual Document { get; }	Obtiene el documento al que pertenece este nodo.
FieldData { get; }	Obtiene datos de campo personalizados que están asociados con el campo.
FieldType { get; }	Devuelve el tipo del campo.
Font { get; }	Proporciona acceso al formato de fuente de este objeto.
virtual IsComposite { get; }	Devuelveverdadero si este nodo puede contener otros nodos.
IsDeleteRevision { get; }	Devuelve verdadero si este objeto se eliminó en Microsoft Word mientras el seguimiento de cambios estaba habilitado.
IsDirty { get; set; }	Obtiene o establece si el resultado actual del campo ya no es correcto (obsoleto) debido a otras modificaciones realizadas al documento.
IsFormatRevision { get; }	Devuelve verdadero si se cambió el formato del objeto en Microsoft Word mientras estaba habilitado el seguimiento de cambios.
IsInsertRevision { get; }	Devuelve verdadero si este objeto se insertó en Microsoft Word mientras el seguimiento de cambios estaba habilitado.
IsLocked { get; set; }	Obtiene o establece si el campo principal está bloqueado (no debe recalcular su resultado).
IsMoveFromRevision { get; }	Devuelveverdadero Si este objeto se movió (eliminó) en Microsoft Word mientras el seguimiento de cambios estaba habilitado.
IsMoveToRevision { get; }	Devuelveverdadero Si este objeto se movió (insertó) en Microsoft Word mientras el seguimiento de cambios estaba habilitado.
NextSibling { get; }	Obtiene el nodo inmediatamente siguiente a este nodo.
override NodeType { get; }	DevuelveFieldStart .
ParentNode { get; }	Obtiene el padre inmediato de este nodo.
ParentParagraph { get; }	Recupera el padreParagraph de este nodo.
PreviousSibling { get; }	Obtiene el nodo inmediatamente anterior a este nodo.
Range { get; }	Devuelve unRangeobjeto que representa la porción de un documento que está contenida en este nodo.

Métodos

Nombre	Descripción
override Accept(DocumentVisitor)	Acepta un visitante.
Clone(bool)	Crea un duplicado del nodo.
GetAncestor(NodeType)	Obtiene el primer ancestro del especificadoNodeType .
GetAncestor(Type)	Obtiene el primer ancestro del tipo de objeto especificado.
GetField()	Devuelve un campo para el campo char.
override GetText()	Obtiene el carácter especial que representa este nodo.
NextPreOrder(Node)	Obtiene el siguiente nodo según el algoritmo de recorrido del árbol de preorden.
PreviousPreOrder(Node)	Obtiene el nodo anterior según el algoritmo de recorrido del árbol de preorden.
Remove()	Se elimina a sí mismo del padre.
ToString(SaveFormat)	Exporta el contenido del nodo en una cadena en el formato especificado.
ToString(SaveOptions)	Exporta el contenido del nodo en una cadena utilizando las opciones de guardado especificadas.

Observaciones

FieldStart es un nodo de nivel en línea y está representado por the FieldStartChar carácter de control en el documento.

FieldStart sólo puede ser hijo deParagraph.

Un campo completo en un documento de Microsoft Word es una estructura compleja que consta de un carácter de inicio, un código, un separador, un resultado y un final. Algunos campos solo tienen inicio, código y final.

Para insertar fácilmente un nuevo campo en un documento, utilice elInsertField Método .

Ejemplos

Muestra cómo trabajar con una colección de campos.

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

    // Iterar sobre la colección de campos e imprimir el contenido y el tipo
    // de cada campo utilizando una implementación de visitante personalizada.
    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>
/// Implementación del documento de visitante que imprime información del campo.
/// </summary>
public class FieldVisitor : DocumentVisitor
{
    public FieldVisitor()
    {
        mBuilder = new StringBuilder();
    }

    /// <summary>
    /// Obtiene el texto simple del documento que fue acumulado por el visitante.
    /// </summary>
    public string GetText()
    {
        return mBuilder.ToString();
    }

    /// <summary>
    /// Se llama cuando se encuentra un nodo FieldStart en el documento.
    /// </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>
    /// Se llama cuando se encuentra un nodo FieldSeparator en el documento.
    /// </summary>
    public override VisitorAction VisitFieldSeparator(FieldSeparator fieldSeparator)
    {
        mBuilder.AppendLine("\tFound separator: " + fieldSeparator.GetText());

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Se llama cuando se encuentra un nodo FieldEnd en el documento.
    /// </summary>
    public override VisitorAction VisitFieldEnd(FieldEnd fieldEnd)
    {
        mBuilder.AppendLine("End of field: " + fieldEnd.FieldType);

        return VisitorAction.Continue;
    }

    private readonly StringBuilder mBuilder;
}

Muestra cómo encontrar todos los hipervínculos en un documento de Word y luego cambiar sus URL y nombres para mostrar.

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

            Los hipervínculos en un documento de Word son campos. Para buscar hipervínculos, primero debemos encontrar todos los campos.
            // Utilice el método "SelectNodes" para encontrar todos los campos del documento a través de un XPath.
            NodeList fieldStarts = doc.SelectNodes("//CampoInicio");

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

                    // Los hipervínculos que enlazan a marcadores no tienen URL.
                    if (hyperlink.IsLocal)
                        continue;

                    // Dale a cada hipervínculo URL una nueva URL y un nombre.
                    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>
      ///Los campos HIPERVÍNCULO contienen y muestran hipervínculos en el cuerpo del documento. Un campo en Aspose.Words
      ///consta de varios nodos y podría resultar difícil trabajar con todos esos nodos directamente.
     ///Esta implementación funcionará solo si el código y el nombre del hipervínculo constan cada uno de un solo nodo Ejecutar.
    ///
     ///La estructura del nodo para los campos es la siguiente:
     ///
     ///[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;

            // Encuentra el nodo separador de campo.
            mFieldSeparator = FindNextSibling(mFieldStart, NodeType.FieldSeparator);
            if (mFieldSeparator == null)
                throw new InvalidOperationException("Cannot find field separator.");

             // Normalmente, siempre podemos encontrar el nodo final del campo, pero el documento de ejemplo
             // contiene un salto de párrafo dentro de un hipervínculo, que coloca el campo al final
             // en el siguiente párrafo. Será mucho más complicado manejar campos que abarcan varios
            // Los párrafos se escriben correctamente. En este caso, basta con que el campo final sea nulo.
            mFieldEnd = FindNextSibling(mFieldSeparator, NodeType.FieldEnd);

            // El código de campo se parece a algo como "HIPERVÍNCULO "http:\\www.myurl.com"", pero puede constar de varias ejecuciones.
            string fieldCode = GetTextSameParent(mFieldStart.NextSibling, mFieldSeparator);
            Match match = gRegex.Match(fieldCode.Trim());

            // El hipervínculo es local si \l está presente en el código de campo.
            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
            {
                 // El nombre para mostrar del hipervínculo se almacena en el resultado del campo, que es una ejecución
                // nodo entre el separador de campo y el final del campo.
                Run fieldResult = (Run) mFieldSeparator.NextSibling;
                fieldResult.Text = value;

                // Si el resultado del campo consta de más de una ejecución, elimine estas ejecuciones.
                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()
        {
            // El código de campo de un campo está en un nodo de ejecución entre el nodo de inicio del campo y el separador de campo.
            Run fieldCode = (Run) mFieldStart.NextSibling;
            fieldCode.Text = string.Format("HYPERLINK {0}\"{1}\"", ((mIsLocal) ? "\\l " : ""), mTarget);

            // Si el código de campo consta de más de una ejecución, elimine estas ejecuciones.
            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+" + // Uno o más HIPERVÍNCULO que no sean espacios u otra palabra en otros idiomas.
            "\\s+" + //Uno o más espacios.
            "(?:\"\"\\s+)?" + // No se captura "" opcional y uno o más espacios.
            "(\\\\l\\s+)?" + // Bandera opcional \l seguida de uno o más espacios.
            "\"" +  // Un apóstrofe.
            "([^\"]+)" + // Uno o más caracteres, excluyendo el apóstrofe (objetivo del hipervínculo).
            "\"" // Un apóstrofe de cierre.
        );
    }
}

Ver también

• class FieldChar
• espacio de nombres Aspose.Words.Fields
• asamblea Aspose.Words