EditableRangeStart

EditableRangeStart class

Rappresenta l’inizio di un intervallo modificabile in un documento Word.

Per saperne di più, visita ilModello oggetto documento Aspose.Words (DOM) articolo di documentazione.

public sealed class EditableRangeStart : Node

Proprietà

Nome	Descrizione
CustomNodeId { get; set; }	Specifica l’identificatore del nodo personalizzato.
virtual Document { get; }	Ottiene il documento a cui appartiene questo nodo.
EditableRange { get; }	Ottiene l’oggetto facciata che incapsula questo intervallo modificabile di inizio e fine.
Id { get; set; }	Specifica l’identificatore dell’intervallo modificabile.
virtual IsComposite { get; }	Restituisce`VERO` se questo nodo può contenere altri nodi.
NextSibling { get; }	Ottiene il nodo immediatamente successivo a questo nodo.
override NodeType { get; }	RestituisceEditableRangeStart .
ParentNode { get; }	Ottiene il genitore immediato di questo nodo.
PreviousSibling { get; }	Ottiene il nodo immediatamente precedente questo nodo.
Range { get; }	Restituisce a`Range` oggetto che rappresenta la porzione di documento contenuta in questo nodo.

Metodi

Nome	Descrizione
override Accept(DocumentVisitor)	Accetta un visitatore.
Clone(bool)	Crea un duplicato del nodo.
GetAncestor(NodeType)	Ottiene il primo antenato dell’oggetto specificato`NodeType` .
GetAncestor(Type)	Ottiene il primo antenato del tipo di oggetto specificato.
virtual GetText()	Ottiene il testo di questo nodo e di tutti i suoi figli.
NextPreOrder(Node)	Ottiene il nodo successivo in base all’algoritmo di attraversamento dell’albero di preordine.
PreviousPreOrder(Node)	Ottiene il nodo precedente in base all’algoritmo di attraversamento dell’albero di preordine.
Remove()	Si rimuove dal genitore.
ToString(SaveFormat)	Esporta il contenuto del nodo in una stringa nel formato specificato.
ToString(SaveOptions)	Esporta il contenuto del nodo in una stringa utilizzando le opzioni di salvataggio specificate.

Osservazioni

Un intervallo modificabile completo in un documento Word è costituito da aEditableRangeStart e una corrispondenzaEditableRangeEnd con lo stesso identificativo.

EditableRangeStart EEditableRangeEnd sono solo indicatori all’interno di un document che specificano dove inizia e finisce l’intervallo modificabile.

Usa ilEditableRange class come “facciata” per lavorare con un range modificabile come un singolo oggetto.

Gli intervalli attualmente modificabili sono supportati solo a livello in linea, ovvero all’internoParagraph, ma l’inizio dell’intervallo modificabile e la fine dell’intervallo modificabile possono trovarsi in paragrafi diversi.

Esempi

Mostra come limitare i diritti di modifica degli intervalli modificabili a un gruppo/utente specifico.

public void Visitor()
{
    Document doc = new Document();
    doc.Protect(ProtectionType.ReadOnly, "MyPassword");

    DocumentBuilder builder = new DocumentBuilder(doc);
    builder.Writeln("Hello world! Since we have set the document's protection level to read-only," +
                    " we cannot edit this paragraph without the password.");

    // Quando proteggiamo i documenti dalla scrittura, gli intervalli modificabili ci consentono di scegliere aree specifiche che gli utenti possono modificare.
    // Esistono due modi reciprocamente esclusivi per restringere l'elenco degli editor consentiti.
    // 1 - Specifica un utente:
    EditableRange editableRange = builder.StartEditableRange().EditableRange;
    editableRange.SingleUser = "john.doe@myoffice.com";
    builder.Writeln($"This paragraph is inside the first editable range, can only be edited by {editableRange.SingleUser}.");
    builder.EndEditableRange();

    Assert.AreEqual(EditorType.Unspecified, editableRange.EditorGroup);

    // 2 - Specificare un gruppo a cui sono associati gli utenti autorizzati:
    editableRange = builder.StartEditableRange().EditableRange;
    editableRange.EditorGroup = EditorType.Administrators;
    builder.Writeln($"This paragraph is inside the first editable range, can only be edited by {editableRange.EditorGroup}.");
    builder.EndEditableRange();

    Assert.AreEqual(string.Empty, editableRange.SingleUser);

    builder.Writeln("This paragraph is outside the editable range, and cannot be edited by anybody.");

    // Stampa i dettagli e il contenuto di ogni intervallo modificabile nel documento.
    EditableRangePrinter editableRangePrinter = new EditableRangePrinter();

    doc.Accept(editableRangePrinter);

    Console.WriteLine(editableRangePrinter.ToText());
}

/// <summary>
/// Raccoglie le proprietà e il contenuto degli intervalli modificabili visitati in una stringa.
/// </summary>
public class EditableRangePrinter : DocumentVisitor
{
    public EditableRangePrinter()
    {
        mBuilder = new StringBuilder();
    }

    public string ToText()
    {
        return mBuilder.ToString();
    }

    public void Reset()
    {
        mBuilder.Clear();
        mInsideEditableRange = false;
    }

    /// <summary>
    /// Chiamato quando nel documento viene rilevato un nodo EditableRangeStart.
    /// </summary>
    public override VisitorAction VisitEditableRangeStart(EditableRangeStart editableRangeStart)
    {
        mBuilder.AppendLine(" -- Editable range found! -- ");
        mBuilder.AppendLine("\tID:\t\t" + editableRangeStart.Id);
        if (editableRangeStart.EditableRange.SingleUser == string.Empty)
            mBuilder.AppendLine("\tGroup:\t" + editableRangeStart.EditableRange.EditorGroup);
        else
            mBuilder.AppendLine("\tUser:\t" + editableRangeStart.EditableRange.SingleUser);
        mBuilder.AppendLine("\tContents:");

        mInsideEditableRange = true;

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Chiamato quando nel documento viene rilevato un nodo EditableRangeEnd.
    /// </summary>
    public override VisitorAction VisitEditableRangeEnd(EditableRangeEnd editableRangeEnd)
    {
        mBuilder.AppendLine(" -- End of editable range --\n");

        mInsideEditableRange = false;

        return VisitorAction.Continue;
    }

    /// <summary>
    /// Chiamato quando nel documento viene incontrato un nodo Esegui. Questo visitatore registra solo le esecuzioni che rientrano negli intervalli modificabili.
    /// </summary>
    public override VisitorAction VisitRun(Run run)
    {
        if (mInsideEditableRange) mBuilder.AppendLine("\t\"" + run.Text + "\"");

        return VisitorAction.Continue;
    }

    private bool mInsideEditableRange;
    private readonly StringBuilder mBuilder;
}

Guarda anche

class Node
spazio dei nomi Aspose.Words
assemblea Aspose.Words

EditableRangeEnd Class EditorType Enum