FieldStart

FieldStart class

Bir belgedeki Word alanının başlangıcını temsil eder.

public class FieldStart : FieldChar

Özellikleri

İsim Tanım
CustomNodeId { get; set; } Özel düğüm tanımlayıcısını belirtir.
virtual Document { get; } Bu düğümün ait olduğu belgeyi alır.
FieldData { get; } Alanla ilişkili özel alan verilerini alır.
FieldType { get; } Alanın türünü döndürür.
Font { get; } Bu nesnenin yazı tipi biçimlendirmesine erişim sağlar.
virtual IsComposite { get; } Bu düğüm başka düğümler içerebiliyorsa true değerini döndürür.
IsDeleteRevision { get; } Bu nesne, değişiklik izleme etkinleştirilirken Microsoft Word’de silindiyse true değerini döndürür.
IsDirty { get; set; } Alandaki geçerli sonucun belgede yapılan diğer değişiklikler nedeniyle artık doğru (eski) olup olmadığını alır veya ayarlar.
IsFormatRevision { get; } Değişiklik izleme etkinken nesnenin biçimlendirmesi Microsoft Word’de değiştirilirse doğru döndürür.
IsInsertRevision { get; } Bu nesne, değişiklik izleme etkinken Microsoft Word’e eklendiyse true değerini döndürür.
IsLocked { get; set; } Üst alanın kilitli olup olmadığını alır veya ayarlar (sonucunu yeniden hesaplamamalıdır).
IsMoveFromRevision { get; } İade doğru değişiklik izleme etkinken bu nesne Microsoft Word’de taşındıysa (silindiyse).
IsMoveToRevision { get; } İade doğru bu nesne, değişiklik izleme etkinken Microsoft Word’de taşındıysa (yerleştirildiyse).
NextSibling { get; } Bu düğümden hemen sonraki düğümü alır.
override NodeType { get; } İadeFieldStart .
ParentNode { get; } Bu düğümün hemen üst öğesini alır.
ParentParagraph { get; } Üst öğeyi alırParagraph bu düğümün.
PreviousSibling { get; } Bu düğümden hemen önceki düğümü alır.
Range { get; } Bir döndürür Menzil belgenin bu düğümde bulunan bölümünü temsil eden nesne.

yöntemler

İsim Tanım
override Accept(DocumentVisitor) Bir ziyaretçiyi kabul eder.
Clone(bool) Düğümün bir kopyasını oluşturur.
GetAncestor(NodeType) Belirtilenin ilk atasını alırNodeType .
GetAncestor(Type) Belirtilen nesne türünün ilk üst öğesini alır.
GetField() char. alanı için bir alan döndürür
override GetText() Bu düğümün temsil ettiği özel karakteri alır.
NextPreOrder(Node) Ön sipariş ağaç geçiş algoritmasına göre sonraki düğümü alır.
PreviousPreOrder(Node) Ön sipariş ağacı geçiş algoritmasına göre önceki düğümü alır.
Remove() Kendini üst öğeden kaldırır.
ToString(SaveFormat) Düğümün içeriğini belirtilen biçimde bir dizeye aktarır.
ToString(SaveOptions) Belirtilen kaydetme seçeneklerini kullanarak düğümün içeriğini bir dizeye aktarır.

Notlar

FieldStart satır içi düzeyde bir düğümdür ve the ile temsil edilirFieldStartChar belgedeki kontrol karakteri.

FieldStart sadece çocuğu olabilirParagraph.

Bir Microsoft Word belgesindeki tam alan, alan başlangıç karakteri, alan kodu, alan ayırıcı karakter, alan sonucu ve alan bitiş karakterinden oluşan karmaşık bir yapıdır. Bazı alanlarda yalnızca alan başlangıcı, alan kodu ve alan sonu bulunur.

Bir belgeye kolayca yeni bir alan eklemek içinInsertField yöntemi.

Örnekler

Bir alan koleksiyonuyla nasıl çalışılacağını gösterir.

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

    // Alan koleksiyonunu yineleyin ve içeriği yazdırın ve yazın
    // özel bir ziyaretçi uygulaması kullanan her alanın.
    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>
/// Alan bilgilerini yazdıran belge ziyaretçisi uygulaması.
/// </summary>
public class FieldVisitor : DocumentVisitor
{
    public FieldVisitor()
    {
        mBuilder = new StringBuilder();
    }

    /// <summary>
    /// Ziyaretçi tarafından toplanan belgenin düz metnini alır.
    /// </summary>
    public string GetText()
    {
        return mBuilder.ToString();
    }

    /// <summary>
    /// Belgede bir FieldStart düğümüyle karşılaşıldığında çağrılır.
    /// </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>
    /// Belgede bir FieldSeparator düğümüyle karşılaşıldığında çağrılır.
    /// </summary>
    public override VisitorAction VisitFieldSeparator(FieldSeparator fieldSeparator)
    {
        mBuilder.AppendLine("\tFound separator: " + fieldSeparator.GetText());

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Belgede bir FieldEnd düğümüyle karşılaşıldığında çağrılır.
    /// </summary>
    public override VisitorAction VisitFieldEnd(FieldEnd fieldEnd)
    {
        mBuilder.AppendLine("End of field: " + fieldEnd.FieldType);

        return VisitorAction.Continue;
    }

    private readonly StringBuilder mBuilder;
}

Bir Word belgesindeki tüm köprülerin nasıl bulunacağını ve ardından bunların URL’lerinin ve görünen adlarının nasıl değiştirileceğini gösterir.

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

            // Word belgelerindeki köprüler alanlardır. Köprüleri aramaya başlamak için önce tüm alanları bulmalıyız.
            // Belgedeki tüm alanları bir XPath aracılığıyla bulmak için "SelectNodes" yöntemini kullanın.
            NodeList fieldStarts = doc.SelectNodes("//FieldStart");

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

                    // Yer imlerine bağlanan köprülerin URL'leri yoktur.
                    if (hyperlink.IsLocal)
                        continue;

                    // Her URL köprüsüne yeni bir URL ve ad verin.
                    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>
    /// KÖPRÜ alanları, belge gövdesinde köprüler içerir ve görüntüler. Aspose.Words'de bir alan 
    /// birkaç düğümden oluşur ve tüm bu düğümlerle doğrudan çalışmak zor olabilir. 
    /// Bu uygulama, yalnızca köprü kodu ve adının her biri yalnızca bir Çalıştırma düğümünden oluşuyorsa çalışır.
    ///
    /// Alanlar için düğüm yapısı aşağıdaki gibidir:
    /// 
    /// [FieldStart][Çalıştır - alan kodu][FieldSeparator][Çalıştır - alan sonucu][FieldEnd]
    /// 
    /// Aşağıda KÖPRÜ alanlarının iki örnek alan kodu verilmiştir:
    /// KÖPRÜ "url"
    /// KÖPRÜ \l "yer imi adı"
    /// 
    /// Bir alanın "Sonuç" özelliği, alanın belge gövdesinde kullanıcıya gösterdiği metni içerir.
    /// </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;

            // Alan ayırıcı düğümünü bulun.
            mFieldSeparator = FindNextSibling(mFieldStart, NodeType.FieldSeparator);
            if (mFieldSeparator == null)
                throw new InvalidOperationException("Cannot find field separator.");

            // Normalde, alanın son düğümünü her zaman bulabiliriz, ancak örnek belge 
            // alan sonunu koyan bir köprünün içinde bir paragraf sonu içerir 
            // sonraki paragrafta. Birkaç alana yayılan alanları işlemek çok daha karmaşık olacaktır. 
            // paragraflar doğru. Bu durumda alan sonunun boş olmasına izin vermek yeterlidir.
            mFieldEnd = FindNextSibling(mFieldSeparator, NodeType.FieldEnd);

            // Alan kodu "HYPERLINK "http:\\www.myurl.com"" gibi bir şeye benziyor, ancak birkaç çalıştırmadan oluşabilir.
            string fieldCode = GetTextSameParent(mFieldStart.NextSibling, mFieldSeparator);
            Match match = gRegex.Match(fieldCode.Trim());

            // Alan kodunda \l varsa, köprü yereldir.
            mIsLocal = match.Groups[1].Length > 0; 
            mTarget = match.Groups[2].Value;
        }

        /// <summary>
        /// Köprünün görünen adını alır veya ayarlar.
        /// </summary>
        internal string Name
        {
            get => GetTextSameParent(mFieldSeparator, mFieldEnd); 
            set
            {
                // Köprü görünen adı, bir Çalıştır olan alan sonucunda saklanır 
                // alan ayırıcı ve alan sonu arasındaki düğüm.
                Run fieldResult = (Run) mFieldSeparator.NextSibling;
                fieldResult.Text = value;

                // Alan sonucu birden fazla çalıştırmadan oluşuyorsa, bu çalıştırmaları silin.
                RemoveSameParent(fieldResult.NextSibling, mFieldEnd);
            }
        }

        /// <summary>
        /// Köprünün hedef URL'sini veya yer imi adını alır veya ayarlar.
        /// </summary>
        internal string Target
        {
            get => mTarget;
            set
            {
                mTarget = value;
                UpdateFieldCode();
            }
        }

        /// <summary>
        /// Köprü hedefi belgenin içinde bir yer imiyse doğrudur. Köprü bir URL ise yanlış.
        /// </summary>
        internal bool IsLocal
        {
            get => mIsLocal; 
            set
            {
                mIsLocal = value;
                UpdateFieldCode();
            }
        }

        private void UpdateFieldCode()
        {
            // Bir alanın alan kodu, alanın başlangıç düğümü ile alan ayırıcı arasındaki bir Çalıştırma düğümündedir.
            Run fieldCode = (Run) mFieldStart.NextSibling;
            fieldCode.Text = string.Format("HYPERLINK {0}\"{1}\"", ((mIsLocal) ? "\\l " : ""), mTarget);

            // Alan kodu birden fazla çalıştırmadan oluşuyorsa, bu çalıştırmaları silin.
            RemoveSameParent(fieldCode.NextSibling, mFieldSeparator);
        }

        /// <summary>
        /// Başlangıç düğümünden başlayarak belirtilen türde veya boş bir düğüm bulana kadar kardeşler arasında gider.
        /// </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>
        /// Baştan sona metin alır, ancak son düğümü içermez.
        /// </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>
        /// Düğümleri başlangıçtan kaldırır, ancak bitiş düğümünü içermez.
        /// Başlangıç ve bitiş düğümlerinin aynı ebeveyne sahip olduğunu varsayar.
        /// </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+" + // Diğer dillerde bir veya daha fazla boşluk olmayan HYPERLINK veya başka bir kelime.
            "\\s+" + // Bir veya daha fazla boşluk.
            "(?:\"\"\\s+)?" + // Yakalamayan isteğe bağlı "" ve bir veya daha fazla boşluk.
            "(\\\\l\\s+)?" + // İsteğe bağlı \l bayrağının ardından bir veya daha fazla boşluk.
            "\"" + // Bir kesme işareti.    
            "([^\"]+)" + // Kesme işareti (köprü hedefi) hariç bir veya daha fazla karakter.
            "\"" // Bir kapanış kesme işareti.
        );
    }
}

Ayrıca bakınız