Dieser Artikel wurde maschinell übersetzt.
OneNote 2010
Erstellen von OneNote 2010-Erweiterungen mit dem OneNote-Objektmodell
Andy Gray
Microsoft Office OneNote ist eine leistungsfähige digitalen Notizbuches zum Sammeln, organisieren, suchen und Freigeben von Informationen. Mit der letzten Version von Microsoft Office 2010 nicht nur verbessert die Benutzerfreundlichkeit für OneNote, aber OneNote-Notizbücher sind jetzt mehr universell verfügbar. Benutzer können Inhalte zwischen Computern über Windows Live synchronisieren; suchen, bearbeiten und Freigeben von Notizen in einem beliebigen Webbrowser; und vollständige Notizbücher von Windows Mobile (und bald, Windows Telefon 7) zugreifen. Darüber hinaus OneNote wurde zuvor nur in einigen Editionen von Office enthalten, aber es ist jetzt in jeder Edition von Office 2010. All diese Faktoren können eine attraktiverer Verkaufschance als je zuvor erstellen, OneNote in Informationen-Management-Lösungen zu integrieren.
In diesem Artikel werde ich einen Überblick über die Entwicklung von Anwendungen, die mit Daten aus Microsoft OneNote 2010 und 2007 zusammen bereitstellen. In dem Prozess vorgestellt ich das Projekt OneNote-Objektmodell, das kostenlos auf CodePlex verfügbar ist und veranschaulichen, wie diese Bibliothek problemlos Informationen aus OneNote-Notizbücher, Abschnitte und Seiten in Client-Anwendungen integrieren kann.
Die Entwicklung von OneNote-Entwicklung
Die erste Version von OneNote 2003 hat eine API zum externen Anwendungen bereitstellen. Allerdings hinzugefügt OneNote 2003 SP 1 kurz darauf eine COM-Bibliothek, die OneNote 1.1-Typbibliothek, die programmgesteuerten Importieren von Bildern, Freihand und HTML in OneNote über eine einfache Klasse namens CSimpleImporter aktiviert aufgerufen. Insbesondere, diese Klasse nur Daten importieren Funktionen bereitgestellt, könnten Sie es zum Senden der Daten in OneNote-Notizbücher, jedoch gab es keine Möglichkeit, wieder programmgesteuert Abrufen von Inhalten aus.
Die Version von OneNote 2007 geschaltet viel leistungsfähigere Entwicklungsfunktionen eine neue COM-API, die die Fähigkeit zum Importieren, exportieren und OneNote 2007 Inhalt programmgesteuert ändern. OneNote-Application-Klasse in der Bibliothek bietet eine umfassende Sammlung von Methoden für das Arbeiten mit:
- Notizbuch-Struktur: zu ermitteln, öffnen, ändern, schließen und Löschen von Notizbüchern, Abschnittsgruppen und Abschnitte
- Inhalt der Seite: entdecken, öffnen, bearbeiten, speichern und Seiteninhalt löschen
- Navigation: suchen, Verknüpfen mit und Navigation zu Seiten und Objekte
Die meisten dieser Methoden zurückzugeben, oder übernehmen die XML-Dokumente, die Seite, die Inhalte und die Struktur des Notizbuchs darstellen. Saul Candib schrieb einer zweiteiligen Reihe, “ What's New für Entwickler in OneNote 2007, ”, werden diese API msdn.microsoft.com/library/ms788684(v=office.12)-und das XML-Schema wird msdn.microsoft.com/library/aa286798(office.12)-detailliert beschrieben.
Das XML-Schema für OneNote 2010 ähnelt erheblich in OneNote 2007. OneNote 2010 führt eine Dateiänderung-Format zur Unterstützung neuer Features (z. B. verknüpfte Notizen, Versionskontrolle, Web sharing, mehrere Ebenen Unterseiten und Unterstützung für die Gleichung). OneNote 2010 können jedoch weiterhin auf OneNote 2007-Notizbücher zu arbeiten, ohne das Dateiformat zu ändern. In OneNote-2010 ergeben Datenabruf von Abschnitten, die in das OneNote 2007-Dateiformat gespeicherte XML-Dokumente ähnlich denen in OneNote 2007. Die wichtigsten Unterschiede im XML-Schema für 2010 OneNote-Abschnitte sind additiv Änderungen zur Unterstützung neuer Features, die weiter oben aufgeführt. Eine neue XMLSchema-Enumeration ist verfügbar, um die OneNote-Schemaversion darstellen; viele der Methoden OneNote neue Überladungen, die einen XMLSchema-Parameter, um anzugeben, dass die Schemaversion, die gewünscht werden.
Hinweis, das die Klasse CSimpleImporter eingeführt in OneNote 2003 und in OneNote 2007 weiterhin verfügbar wurde entfernt OneNote 2010, damit Anwendungen, die diese Klasse verwenden, müssen neu geschrieben werden muss, verwenden Sie die neuen Schnittstellen zum Arbeiten mit OneNote 2010.
Zugreifen auf OneNote-Daten, die mithilfe der COM-API
Es ist relativ einfach, zur Verwendung von OneNote COM-API zu Livedaten aus OneNote-Notizbücher zugreifen. Zunächst erstellen eine neue Konsolenanwendung in Visual Studio, und fügen Sie einen Verweis auf die Microsoft OneNote 14.0 Type Library COM-Komponente (für OneNote 2010) oder die Microsoft OneNote 12.0 Type Library COM-Komponente (für OneNote 2007).
Wenn Sie über Visual Studio 2010 OneNote 2010 Anwendungen entwickeln, untersuchen Sie einige geringfügige Kompatibilitätsprobleme. Erstens aufgrund von OneNote Interop-Assembly, die im Lieferumfang von Visual Studio 2010-Konflikt sollte Sie nicht direkt verweisen the Microsoft.Office.Interop.OneNote-Komponente auf der Registerkarte .NET des Dialogfelds Verweis hinzufügen, aber stattdessen auf der Registerkarte COM Komponente Microsoft OneNote 14.0-Typbibliothek verweisen. Dies führt immer noch eine Interop-Assembly von OneNote in Ihrem Projekt Verweise hinzufügen.
Zweitens ist OneNote 14.0-Typbibliothek nicht kompatibel mit dem Visual Studio 2010 “ NOPIA ” Feature (in der primären Interop-Assemblys nicht in der Anwendung standardmäßig eingebettet werden). Stellen Sie daher sicher, dass die Eigenschaft einbetten Interop-Typen für den OneNote-Interop-Assemblyverweis auf False festgelegt. (Diese beiden Probleme werden ausführlich im Blog von OneNote-Programmmanager Daniel Escapa blogs.msdn.com/descapa/archive/2010/04/27/onenote-2010-and-visual-studio-2010-compatibility-issues.aspx von beschrieben.) Mit dem OneNote-Bibliothek-Verweis vorhanden können Sie OneNote-API aufrufen. Der Code in Abbildung 1 GetHierarchy-Methode verwendet, um ein XML-Dokument mit einer Liste der OneNote-Notizbücher abzurufen und anschließend verwendet LINQ to XML zu extrahieren, und Drucken die Notizbuch Namen auf der Konsole.
Abbildung 1 zählen Notizbücher
using System;
using System.Linq;
using System.Xml.Linq;
using Microsoft.Office.Interop.OneNote;
class Program
{
static void Main(string[] args)
{
var onenoteApp = new Application();
string notebookXml;
onenoteApp.GetHierarchy(null, HierarchyScope.hsNotebooks, out notebookXml);
var doc = XDocument.Parse(notebookXml);
var ns = doc.Root.Name.Namespace;
foreach (var notebookNode in
from node in doc.Descendants(ns + "Notebook") select node)
{
Console.WriteLine(notebookNode.Attribute("name").Value);
}
}
}
HierarchyScope-Enumeration, die als zweiter Parameter übergeben wird, der GetHierarchy-Methode gibt die Tiefe der Notebook-Struktur abrufen. Abrufen von Abschnitten in der Notizbücher HierarchyScope.hsSections aktualisieren Sie dieser Enumerationswert und verarbeiten Sie die zusätzlichen XML-untergeordneten Knoten als nachgewiesenen in Abbildung 2 .
Abbildung 2 zählen Abschnitte
using System;
using System.Linq;
using System.Xml.Linq;
using Microsoft.Office.Interop.OneNote;
class Program
{
static void Main(string[] args)
{
var onenoteApp = new Application();
string notebookXml;
onenoteApp.GetHierarchy(null, HierarchyScope.hsSections, out notebookXml);
var doc = XDocument.Parse(notebookXml);
var ns = doc.Root.Name.Namespace;
foreach (var notebookNode in from node in doc.Descendants(ns +
"Notebook") select node)
{
Console.WriteLine(notebookNode.Attribute("name").Value);
foreach (var sectionNode in from node in
notebookNode.Descendants(ns + "Section") select node)
{
Console.WriteLine(" " + sectionNode.Attribute("name").Value);
}
}
}
}
Abrufen und Aktualisieren von Seiteninhalt
Die GetPageContent-Methode gibt ein XML-Dokument mit der gesamte Inhalt auf einer angegebenen Seite zurück. Zum Abrufen die Seite wird mithilfe einer OneNote-Objekt-ID einer zeichenfolgenbasierten eindeutiger Bezeichner für jedes Objekt in der OneNote-Notizbuch-Hierarchie angegeben. Diese Objektkennung ist als ein Attribut von der GetHierarchy-Methode zurückgegebenen XML-Knoten enthalten.
Abbildung 3 baut auf den vorherigen Beispielen, mit die GetHierarchy-Methode zum Abrufen von OneNote-Notizbuch-Hierarchie nach unten zum Seitenbereich der. Dann wird LINQ to XML verwendet, wählen Sie den Knoten für die Seite mit dem Namen “ Test Seite ” und Objekt-ID für diese Seite an die GetPageContent-Methode übergeben. Das XML-Dokument, das den Seiteninhalt darstellt wird anschließend an die Konsole ausgegeben.
Abbildung 3 erste Seiteninhalt
using System;
using System.Linq;
using System.Xml.Linq;
using Microsoft.Office.Interop.OneNote;
class Program
{
static void Main(string[] args)
{
var onenoteApp = new Application();
string notebookXml;
onenoteApp.GetHierarchy(null, HierarchyScope.hsPages, out notebookXml);
var doc = XDocument.Parse(notebookXml);
var ns = doc.Root.Name.Namespace;
var pageNode = doc.Descendants(ns + "Page").Where(n =>
n.Attribute("name").Value == "Test page").FirstOrDefault();
if (pageNode != null)
{
string pageXml;
onenoteApp.GetPageContent(pageNode.Attribute("ID").Value, out pageXml);
Console.WriteLine(XDocument.Parse(pageXml));
}
}
}
UpdatePageContent-Methode kann verwendet werden, um einer Seite ändern. Der Seiteninhalt wird angegeben, indem das gleiche Schema der XML-Dokument, dass der Code in Abbildung 3 abgerufen; enthalten verschiedene Inhaltselemente Textumrisse, eingefügte Dateien, Bilder, Freihand und Audio-oder Videodateien zu definieren.
UpdatePageContent-Methode behandelt die Elemente im bereitgestellten XML-Dokument als eine Sammlung von Inhalten, die sich möglicherweise geändert haben, entsprechen angegebenen Inhalt zu vorhandenen Inhalten über Ihre OneNote-Objekt-ID. Sie können daher Änderungen zu vorhandenen Inhalten durch Aufrufen der Methode GetPageContent vornehmen, die gewünschten Änderungen an der XML-Code zurückgegeben wird, dann UpdatePageContent-Methode sichern und diese XML-Daten übergeben. Sie können auch neue Inhaltselemente zu der Seite hinzugefügt werden, angeben.
Um dies zu verdeutlichen, fügt Abbildung 4 einen Datumsstempel an das Ende der Testseite. Es verwendet den in Abbildung 3 dargestellte Ansatz zur Bestimmung der OneNote-Objekt-ID der Seite und verwendet dann die XDocument und XElement in System.Xml.Linq zum Erstellen eines XML-Dokuments, das den neuen Inhalt enthält. Da Page-Objekt-ID im Dokument angegeben, die Objekt-ID einer vorhandenen Seite übereinstimmt, wird die UpdatePageContent-Methode den neuen Inhalt der vorhandenen Seite angefügt.
Abbildung 4 Aktualisieren Seiteninhalt
using System;
using System.Linq;
using System.Xml.Linq;
using Microsoft.Office.Interop.OneNote;
class Program
{
static void Main(string[] args)
{
var onenoteApp = new Application();
string notebookXml;
onenoteApp.GetHierarchy(null, HierarchyScope.hsPages, out notebookXml);
var doc = XDocument.Parse(notebookXml);
var ns = doc.Root.Name.Namespace;
var pageNode = doc.Descendants(ns + "Page").Where(n =>
n.Attribute("name").Value == "Test page").FirstOrDefault();
var existingPageId = pageNode.Attribute("ID").Value;
if (pageNode != null)
{
var page = new XDocument(new XElement(ns + "Page",
new XElement(ns + "Outline",
new XElement(ns + "OEChildren",
new XElement(ns + "OE",
new XElement(ns + "T",
new XCData("Current date: " +
DateTime.Now.
ToLongDateString())))))));
page.Root.SetAttributeValue("ID", existingPageId);
onenoteApp.UpdatePageContent(page.ToString(), DateTime.MinValue);
}
}
}
Die OneNote-Model-Objektbibliothek
Ist es nicht besonders schwierig, Interaktion mit OneNote-Daten auf diese Weise, aber es ist etwas unhandlich, analysieren und Erstellen von XML-Dokumenten, um grundlegende Datenvorgänge ausführen. Kommt das OneNote-Objektmodell. Es ist eine Bibliothek verwalteten Code, die objektorientierten Abstraktionen über OneNote-COM-basierte API ermöglicht. Die Bibliothek ist open Source und unter der öffentlichen Microsoft-Lizenz (MS-PL) lizenziert.
OneNote-Objektmodell steht unter zum Download auf CodePlex onom.codeplex.com. Die Bibliothek für OneNote 2007 entwickelt wurde, und sobald Sie diesen Artikel lesen, sollten die Release-Downloads auf Kompatibilität mit OneNote 2010 aktualisiert werden. Wenn dies nicht der Fall ist, noch können Sie mit OneNote 2007-Abschnitte in OneNote 2010, downloaden den Quellcode, entfernen den vorhandenen Microsoft.Office.Interop.OneNote Assemblyverweis im Projekt OneNoteCore und das Hinzufügen eines Verweises auf die Typbibliothek von Microsoft OneNote 14.0, wie zuvor gezeigt.
Neben einigen Einheit Testprojekte und Beispielcode enthält die Lösung zwei Klassenbibliotheksprojekte: OneNoteCore und OneNoteFramework. Die Bibliothek OneNoteCore Low-Level-Brücke zwischen dem OneNote COM-API und vertraute Metaphern von Microsoft .NET Framework; real Rückgabewerte anstelle von COM- , Parameter stellt, COM-Fehlercodes in .NET Ausnahmen konvertiert, stellt eine Struktur OneNoteObjectId und XDocument-Instanzen, anstelle des unformatierten Zeichenfolgen. Dieser Code untersuchen, hilft Ihnen beim Verständnis der Funktionsweise von OneNote-API, aber in den meisten Fällen müssen Sie nicht direkt mit der Bibliothek OneNoteCore interagieren.
Die OneNoteFramework-Bibliothek stellt auf höherer Ebene Abstraktionen von OneNote-Konzepte. Hier finden Sie Klassen mit intuitiven Namen wie OneNoteNotebook, OneNoteSection und OneNotePage. Der primäre Einstiegspunkt für die Interaktion mit der OneNote-Hierarchiestruktur wird eine Klasse namens „ OneNoteHierarchy, die einen statischen Member aufgerufen, aktuell enthält. Einen Assemblyverweis auf die Bibliothek OneNoteFramework hinzugefügt wird, können wir unser Programm Notizbuch Namen ( Abbildung 1 ) aufgelistet werden wesentlich kürzer wie folgt umschreiben:
using Microsoft.Office.OneNote;
class Program
{
static void Main(string[] args)
{
foreach (var notebook in OneNoteHierarchy.Current.Notebooks)
System.Console.WriteLine(notebook.Name);
}
}
Wie zu erwarten, hat die OneNoteNotebook-Klasse eine Eigenschaft namens „ Sections. Daher können Sie die Abschnittsnamen ( Abbildung 2 ) durchlaufen, einfach wie folgt:
using Microsoft.Office.OneNote;
class Program
{
static void Main(string[] args)
{
foreach (var notebook in OneNoteHierarchy.Current.Notebooks)
{
System.Console.WriteLine(notebook.Name);
foreach (var section in notebook.Sections)
{
System.Console.WriteLine(" " + section.Name);
}
}
}
}
Auflistungen von Eigenschaften der OneNote-Objektmodell verfügbar gemacht werden, werden mit einer spezialisierten generischen Auflistungsklasse OneNoteObjectCollection <T> aufgerufen verwaltet. Da OneNoteObjectCollection <T> IList <T> sowie IEnumerable <T> implementiert wird, können diese Auflistungen mithilfe von LINQ abgefragt werden.
Beispielsweise konnte erhält einen Verweis auf eine Instanz OneNoteSection in der Variablen im Abschnitt, wir alle Seiten bestimmen, die heute mit einem einfachen LINQ-Ausdruck wie folgt geändert worden:
var pagesModifiedToday = from page in section.Pages
where page.LastModifiedTime >= DateTime.Today
select page;
Datenbindung mit OneNote Model-Objektbibliothek
Die Tatsache, dass der OneNote-Objektmodell IEnumerable-Auflistungen offen legt ermöglicht auch die XAML-basierte Datenbindung mit Windows Presentation Foundation (WPF). Abbildung 5 d veranschaulicht die Verwendung der Datenbindung an eine WPF-Strukturansicht der Hierarchie der OneNote-Notizbuch rein in XAML-Markup anzuzeigen, ohne die Verwendung von Code.
Abbildung 5 Datenbindung mit Windows Presentation Foundation
<Window x:Class="NotebookTree.MainWindow"
xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
xmlns:onf="clr-namespace:Microsoft.Office.OneNote;assembly=
OneNoteFramework"
Title="OneNote Notebook Hierarchy" >
<Grid>
<Grid.Resources>
<DataTemplate x:Key="PageTemplate">
<StackPanel Orientation="Horizontal">
<Image Source="Images\Page16.png" Margin="0,0,2,0"/>
<TextBlock Text="{Binding Name}" />
</StackPanel>
</DataTemplate>
<HierarchicalDataTemplate x:Key="SectionTemplate"
ItemsSource="{Binding Pages}"
ItemTemplate="{StaticResource PageTemplate}">
<StackPanel Orientation="Horizontal">
<Image Source="Images\Section16.png" Margin="0,0,2,0"/>
<TextBlock Text="{Binding Name}" />
</StackPanel>
</HierarchicalDataTemplate>
<HierarchicalDataTemplate x:Key="NotebookTemplate"
ItemsSource="{Binding Sections}"
ItemTemplate="{StaticResource SectionTemplate}">
<StackPanel Orientation="Horizontal">
<Image Source="Images\Book16.png" Margin="0,0,2,0"/>
<TextBlock Text="{Binding Name}" />
</StackPanel>
</HierarchicalDataTemplate>
</Grid.Resources>
<TreeView Name="NotebookTree" BorderThickness="0"
HorizontalAlignment="Left" VerticalAlignment="Top"
ItemsSource="{Binding Notebooks}"
ItemTemplate="{StaticResource NotebookTemplate}"
DataContext="{Binding Source={x:Static
onf:OneNoteHierarchy.Current}}" />
</Grid>
</Window>
Dieses XAML verweist zuerst OneNoteFramework-Assembly, die den XML-Namespace-Präfix Onf zuweisen.Mit diesem Verweis vorhanden kann der DataContext für die TreeView auf die statische Current-Eigenschaft der Klasse OneNoteHierarchy festlegen werden die Kontrolle, die den Stamm der OneNote-Hierarchiestruktur.HierarchicalDataTemplates werden dann verwendet, um die Datenbindung jede Ebene der Struktur mit der entsprechenden Auflistung verfügbar gemacht, von OneNote-Objektmodell (siehe Abbildung 6 ).
.jpg)
Abbildung 6 Data Binding der Hierarchie an eine Baumansicht
Vereinfachte Datenzugriff
Nachbereiten, vereinfacht die OneNote-Objektmodell-Bibliothek erheblich Zugriff auf Daten in Microsoft OneNote-Notizbücher, Verfügbarmachen von Rich-Objektauflistungen, die abgefragt und mit LINQ-Ausdrücke und WPF-Datenbindung bearbeitet werden können.Weiterverfolgungs-Artikel wird diese Konzepte zu erkunden, arbeiten mit OneNote-Notizbücher in Silverlight und Windows-Telefon-Anwendungen und den Zugriff auf Daten von OneNote in der Wolke erweitern.
Andy Gray ist Direktor-Partner und der Technologie von fünf Talent-Software, die helfen, gemeinnütziger Organisationen arbeiten effektiver durch strategische Technologie Lösungen Er schreibt zur Entwicklung von OneNote. onenotedev.com-.
Dank an die folgenden technischen Experten für die Überprüfung der in diesem Artikel: Michael Gerfen und John Guin.