Arbeiten mit OneNote -Dokument

OneNote -Inhalt mit Dokumentvisor extrahieren

Aspose.Note kann verwendet werden, um Microsoft Office OneNote -Dokumente zu analysieren, um separate Dokumentelemente wie Seiten, Bilder, reichhaltige Text, Umriss, Titel, Tabelle, angehängte Dateien und andere zu extrahieren. Eine andere mögliche Aufgabe ist es, den gesamten Text zu finden und eine Gesamtzahl von Knoten usw. zu erhalten.

Verwenden Sie die Klasse documentvisitor, um dieses Nutzungsszenario zu implementieren. Diese Klasse entspricht dem bekannten Besucherdesignmuster. Mit Dokumentvisor können Sie benutzerdefinierte Vorgänge definieren und ausführen, die eine Aufzählung über den Dokumentbaum erfordern.

DocumentVisitor bietet eine Reihe von Visitxxx -Methoden, die aufgerufen werden, wenn ein bestimmtes Dokumentelement (Knoten) auftritt. Beispielsweise wird documentvisitor.visitrichtextStart aufgerufen, wenn der Textelement startet und Dokumentvisor.visItimageend aufgerufen wird, wenn der Besucher alle Kinderknoten besucht hat. Jede Dokumentvisor.VISITXXX -Methode akzeptiert das entsprechende Objekt, auf das er begegnet ist, damit Sie es bei Bedarf verwenden können.

Dies sind die Schritte, die Sie ausführen sollten, um verschiedene Teile eines Dokuments programmgesteuert zu bestimmen und zu extrahieren:

1. Erstellen Sie eine von Dokumentvisor abgeleitete Klasse.
2. Überschreiben und Bereitstellung von Implementierungen für einige oder alle der Dokumentvisor.vissitxxx -Methoden zur Durchführung kundenspezifischer Vorgänge.
3. Rufen Sie Knoten.Accept auf dem Knoten, von dem Sie die Aufzählung beginnen möchten. Wenn Sie beispielsweise das gesamte Dokument aufzählen möchten, verwenden Sie document.accept.

DocumentVisitor stellt Standardimplementierungen für alle Dokumentvisor.vissitxxx -Methoden bereit. Dies erleichtert das Erstellen neuer Dokumentbesucher, da nur die für den jeweiligen Besucher erforderlichen Methoden überschrieben werden müssen. Es ist nicht erforderlich, alle Besuchermethoden zu überschreiben.

Das folgende Codebeispiel zeigt, wie das Besuchermuster zum Hinzufügen neuer Operationen zum Aspose. ANTE -Objektmodell hinzugefügt wird. In diesem Fall erstellen wir einen einfachen Dokumentkonverter in ein Textformat.

public static void Run()
{            
    // The path to the documents directory.
    string dataDir = RunExamples.GetDataDir_LoadingAndSaving();

    // Open the document we want to convert.
    Document doc = new Document(dataDir + "Aspose.one");

    // Create an object that inherits from the DocumentVisitor class.
    MyOneNoteToTxtWriter myConverter = new MyOneNoteToTxtWriter();

    // This is the well known Visitor pattern. Get the model to accept a visitor.
    // The model will iterate through itself by calling the corresponding methods
    // on the visitor object (this is called visiting).
    //
    // Note that every node in the object model has the Accept method so the visiting
    // can be executed not only for the whole document, but for any node in the document.
    doc.Accept(myConverter);

    // Once the visiting is complete, we can retrieve the result of the operation,
    // that in this example, has accumulated in the visitor.
    Console.WriteLine(myConverter.GetText());
    Console.WriteLine(myConverter.NodeCount);            
}

/// <summary>
/// Simple implementation of saving a document in the plain text format. Implemented as a Visitor.
/// </summary>
public class MyOneNoteToTxtWriter : DocumentVisitor
{
    public MyOneNoteToTxtWriter()
    {
        nodecount = 0;
        mIsSkipText = false;
        mBuilder = new StringBuilder();
    }

    /// <summary>
    /// Gets the plain text of the document that was accumulated by the visitor.
    /// </summary>
    public string GetText()
    {
        return mBuilder.ToString();
    }

    /// <summary>
    /// Adds text to the current output. Honors the enabled/disabled output flag.
    /// </summary>
    private void AppendText(string text)
    {
        if (!mIsSkipText)
            mBuilder.Append(text);
    }

    /// <summary>
    /// Called when a RichText node is encountered in the document.
    /// </summary>
    public override void VisitRichTextStart(RichText run)
    {
        ++nodecount;
        AppendText(run.Text);
    }

    /// <summary>
    /// Called when a Document node is encountered in the document.
    /// </summary>
    public override void VisitDocumentStart(Document document)
    {
        ++nodecount;
    }

    /// <summary>
    /// Called when a Page node is encountered in the document.
    /// </summary>
    public override void VisitPageStart(Page page)
    {
        ++nodecount;
    }

    /// <summary>
    /// Called when a Title node is encountered in the document.
    /// </summary>
    public override void VisitTitleStart(Title title)
    {
        ++nodecount;
    }

    /// <summary>
    /// Called when a Image node is encountered in the document.
    /// </summary>
    public override void VisitImageStart(Image image)
    {
        ++nodecount;
    }

    /// <summary>
    /// Called when a OutlineGroup node is encountered in the document.
    /// </summary>
    public override void VisitOutlineGroupStart(OutlineGroup outlineGroup)
    {
        ++nodecount;
    }

    /// <summary>
    /// Called when a Outline node is encountered in the document.
    /// </summary>
    public override void VisitOutlineStart(Outline outline)
    {
        ++nodecount;
    }

    /// <summary>
    /// Called when a OutlineElement node is encountered in the document.
    /// </summary>
    public override void VisitOutlineElementStart(OutlineElement outlineElement)
    {
        ++nodecount;
    }

    /// <summary>
    /// Gets the total count of nodes by the Visitor
    /// </summary>
    public Int32 NodeCount
    {
        get { return this.nodecount; }
    }

    private readonly StringBuilder mBuilder;
    private bool mIsSkipText;
    private Int32 nodecount;
}

Aspose.Note Dokumentobjektmodell

Knotenklassen

Wenn Aspose.Note ein OneNote -Dokument in den Speicher liest, werden Objekte verschiedener Typen erstellt, um verschiedene Dokumentelemente darzustellen. Jeder Richtext von Text, Titel, Tabelle und sogar der OneNote selbst ist ein Knoten. ASSONE.Note definiert eine Klasse für jede Art von Dokumentknoten.

Die folgende Abbildung ist ein UML -Klassendiagramm, das die Vererbung zwischen Knotenklassen des Aspose.Honby -Dokumentobjektmodells (DOM) zeigt. Die Namen abstrakter Klassen sind Knoten und Compositode. Bitte beachten Sie, dass die Aspose.Note-Dom auch Nicht-Notenklassen wie ParagraphStyle, Margen, NumberList , usw. enthält, die nicht an der Vererbung teilnehmen und in diesem Diagramm nicht angezeigt werden.

In der folgenden Tabelle sind Aspose. ANTE -Knotenklassen mit kurzen Beschreibungen aufgelistet.

Aspose.Note Class	Category	Description
Document	Document	A document object that, as the root of the document tree, provides access to the entire OneNote document.
Title	Title	A page title of OneNote document.
Page	Page	A page of OneNote document.
AttachedFile	File	Represents an attached file within the OneNote document.
Image	Image	Represents an image file within the OneNote document.
OutlineGroup	Outline	Represents a group of outlines.
OutlineElement	Outline	Represents an outline element.
Outline	Outline	Represents an outline.
Table	Tables	A table in a OneNote document.
TableCell	Tables	A cell of a table row.
TableRow	Tables	A row of a table.
RichText	Text	A RichText of text with consistent formatting.
The following table lists Aspose.Note base node classes that help to form the class hierarchy.

Class	Description
Node	Abstract base class for all nodes of a OneNote document. Provides basic functionality of a child node.
CompositeNode	Base class for nodes that can contain other nodes. Provides operations to access, insert, remove, and select child nodes.

Unterscheiden Sie Knoten von Nodetype

Obwohl die Klasse des Knotens ausreicht, um verschiedene Knoten voneinander zu unterscheiden, liefert Aspose.Se. Starten liefert die Nodetype -Aufzählung, um einige API -Aufgaben zu vereinfachen, z. B. die Auswahl der Knoten eines bestimmten Typs. Der Typ jedes Knotens kann unter Verwendung der Aufzählung von Nodetyp erhalten werden. Dies gibt einen Nodetype Aufzählungswert zurück. Beispielsweise gibt ein Richtext -Knoten (dargestellt durch den RichText Klasse) nodetype.richtext zurück, ein Tabellenknoten (dargestellt durch die {**} -Tabelle {*} Klasse) gibt nodetype.table und so auf.

Das folgende Codebeispiel zeigt, wie die Nodetype -Aufzählung verwendet wird.

// The path to the documents directory.
Document doc = new Document();

// Returns NodeType.Document
NodeType type = doc.NodeType;

Erstellen Sie ein leeres OneNote -Dokument mit einem Seitentitel

Aspose.Note für .NET unterstützt die Generierung von OneNote -Dokumenten von Grund auf neu.

Verwenden Sie den unten angegebenen Code -Snippet, um ein neues Dokument mit einem Titel zu erstellen.

Dieses Beispiel funktioniert wie folgt:

1. Erstellen Sie ein Objekt der Dokument Klasse.
2. Initialisieren Sie das Objekt der Seitenklasse, indem Sie das Dokumentklassenobjekt übergeben.
3. Setzen Sie Seite. Title -Objekteigenschaften.
4. Die AppendChild -Methode von Dokumentklasse und das Übergeben von Seitenklassenobjekt.
5. Speichern Sie es schließlich, indem Sie die Speichermethode der Dokumentklasse aufrufen.

Der folgende Code -Snippet zeigt, wie ein leeres OneNote -Dokument mit einem Seitentitel erstellt wird

// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_LoadingAndSaving();

// Create an object of the Document class
Document doc = new Aspose.Note.Document();
// Initialize Page class object
Aspose.Note.Page page = new Aspose.Note.Page(doc);

// Default style for all text in the document.
ParagraphStyle textStyle = new ParagraphStyle { FontColor = Color.Black, FontName = "Arial", FontSize = 10 };
// Set page title properties
page.Title = new Title(doc)
{
    TitleText = new RichText(doc) { Text = "Title text.", ParagraphStyle = textStyle },
    TitleDate = new RichText(doc) { Text = new DateTime(2011, 11, 11).ToString("D", CultureInfo.InvariantCulture), ParagraphStyle = textStyle },
    TitleTime = new RichText(doc) { Text = "12:34", ParagraphStyle = textStyle }
};
// Append Page node in the document
doc.AppendChildLast(page);

dataDir = dataDir + "CreateDocWithPageTitle_out.one";
// Save OneNote document
doc.Save(dataDir);

Dateiformatinformationen abrufen

Aspose.NoteAPI unterstützt Microsoft OneNote sowie OneNote -Online -Dateiformate. Die Lateral hat einige Einschränkungen, wie z. B. keine Unterstützung für Anhänge und Bilder im Dokument sind nicht verfügbar. Um die Benutzer zu diesen beiden verschiedenen Arten von Dokumenten zu führen, bietet die API die Methode zur Bestimmung des Dateiformates des OneNote -Dokuments, um die Einschränkungen zu kennen, bis diese vollständig unterstützt werden.

Das folgende Codebeispiel zeigt, wie die Dateiformatinformationen des OneNote -Dokuments mithilfe der Dateiformat -Eigenschaft der Dokumentklasse abgerufen werden.

// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_LoadingAndSaving();

var document = new Aspose.Note.Document(dataDir + "Aspose.one");
switch (document.FileFormat)
{
    case FileFormat.OneNote2010:
        // Process OneNote 2010
        break;
    case FileFormat.OneNoteOnline:
        // Process OneNote Online
        break;
}