Este artigo foi traduzido por máquina.

OneNote 2010

Criando extensões do OneNote 2010 com o modelo de objeto do OneNote

Andy Gray

Baixe o código de exemplo

O Microsoft Office OneNote é um bloco de anotações digital poderoso para coletar, organizar, pesquisar e compartilhar informações. Com o lançamento recente do Microsoft Office 2010, não apenas a experiência de usuário do OneNote aperfeiçoada, mas blocos de anotações do OneNote estão disponíveis mais universalmente. Os usuários podem sincronizar conteúdo entre computadores por meio do Windows Live; pesquisar, editar e compartilhar anotações de qualquer navegador da Web; e acessar os blocos de anotações completos do Windows Mobile (e, em breve, o Windows telefone 7). Além disso, o OneNote anteriormente era incluído somente em algumas edições do Office, mas ele está agora em todas as edições do Office 2010. Todos esses fatores criam uma oportunidade de mais interessante que nunca para integrar o OneNote em soluções de gerenciamento de informações.

Neste artigo, eu fornecerá uma visão geral sobre o desenvolvimento de aplicativos que interagem com dados do Microsoft OneNote 2010 e 2007. O processo, apresentarei o projeto de modelo de objeto do OneNote está disponível gratuitamente no CodePlex e demonstre como essa biblioteca facilita integrar informações de blocos de anotações, seções e páginas do OneNote em aplicativos cliente.

A evolução do desenvolvimento do OneNote

A versão inicial do OneNote 2003 não forneceu uma API para aplicativos externos. Logo depois, no entanto, o OneNote 2003 SP 1 adicionou uma biblioteca COM, chamada de biblioteca de tipos de 1. 1 o OneNote, habilitado através de programação de importação de imagens, tinta e HTML no OneNote, por meio de uma classe simples denominada CSimpleImporter. Em especial, no entanto, essa classe fornecida apenas recursos de importação de dados; você pode usá-lo para enviar dados em blocos de anotações do OneNote, mas não havia nenhuma maneira de obter o conteúdo fazer check-out por meio de programação.

O lançamento do OneNote 2007 trouxe muito mais poderosos recursos de desenvolvimento com uma nova API COM, que fornece a capacidade para importar, exportar e modificar o conteúdo do OneNote 2007 por meio de programação. A classe de aplicativo OneNote nessa biblioteca fornece um rico conjunto de métodos para trabalhar com:

  • Estrutura de bloco de anotações: descobrindo, abrir, modificar, fechando e a exclusão de blocos de anotações, seções e grupos de seções
  • Conteúdo de página: descobrindo, abrir, modificar, salvando e excluindo o conteúdo da página
  • Navegação: Localizando, vinculando a e navegar para páginas e objetos

A maioria dos métodos a seguir retorna ou aceita documentos XML que representam a estrutura de bloco de anotações e o conteúdo da página. Saul Candib escreveu uma série de duas partes, “ o que de novo para desenvolvedores no OneNote 2007, ” que documenta este API em msdn.microsoft.com/library/ms788684(v=office.12)de , e o esquema XML é detalhado em msdn.microsoft.com/library/aa286798(office.12) de .

O esquema XML para o OneNote 2010 é substancialmente semelhante no OneNote 2007. O OneNote 2010 introduz uma alteração de formato de arquivo para oferecer suporte a alguns dos seus novos recursos (como anotações vinculadas, o controle de versão, as subpáginas de compartilhamento, com vários níveis da Web e suporte a equação). No entanto, o OneNote 2010 pode continuar a trabalhar em blocos de anotações do OneNote 2007 sem alterar o formato de arquivo. No OneNote 2010, recuperando dados de seções armazenadas em formato de arquivo do OneNote 2007 produzirá documentos XML semelhantes no OneNote 2007. As principais diferenças no esquema XML para as seções do OneNote 2010 são aditivas alterações para oferecer suporte os novos recursos listados anteriormente. Uma nova enumeração XMLSchema está disponível para representar a versão de esquema do OneNote; muitos métodos os OneNote tem novas sobrecargas que recebem um parâmetro XMLSchema para indicar a versão do esquema desejada.

Observe que a classe CSimpleImporter, introduzido no OneNote 2003 e ainda está disponível no OneNote 2007 foi removido do OneNote 2010, portanto, os aplicativos que usam essa classe precisará ser reescrita para usar as novas interfaces para trabalhar com o OneNote 2010.

Acessando dados do OneNote usando a API COM

É bem simples começar a usar a API COM do OneNote para acessar dados em tempo real de blocos de anotações do OneNote. Comece criando um novo aplicativo console no Visual Studio e, em seguida, adicione uma referência ao componente COM do Microsoft OneNote 14.0 Type Library (para o OneNote 2010) ou o componente COM do Microsoft OneNote 12. 0 Type Library (para o OneNote 2007).

Se você estiver usando o Visual Studio 2010 para desenvolver aplicativos do OneNote 2010, tome nota de alguns pequenos problemas de compatibilidade. Em primeiro lugar, devido a uma incompatibilidade do assembly de interoperabilidade do OneNote que acompanha o Visual Studio 2010, você deve the
Microsoft.Office.Interop.OneNote componente na guia .net, da caixa de diálogo Adicionar referência de referência não diretamente, mas em vez disso, referenciar o componente de biblioteca de tipos do Microsoft OneNote 14.0 na guia COM. Isso ainda resulta da adição de um assembly de interoperabilidade do OneNote para referências do projeto.

Em segundo lugar, a biblioteca de tipos de 14.0 o OneNote não é compatível com o recurso Visual Studio 2010 “ NOPIA ” (os assemblies de interoperabilidade primários não são incorporados no aplicativo por padrão). Portanto, certifique-se de definir a propriedade de incorporar tipos de interoperabilidade para false para a referência de assembly de interoperabilidade do OneNote. (Esses dois problemas são descritos mais detalhadamente no blog do gerente de programa do OneNote Daniel Escapa em blogs.msdn.com/descapa/archive/2010/04/27/onenote-2010-and-visual-studio-2010-compatibility-issues.aspx de .) Com a referência de biblioteca do OneNote no lugar, você estará pronto para fazer chamadas à API do OneNote. Do Figura 1 o código usa o método de GetHierarchy para recuperar um documento XML que contém uma lista de blocos de anotações do OneNote, e em seguida, usa LINQ para XML para extrair e imprimir os nomes de bloco de anotações ao console.

Figura 1 do enumerando blocos de anotações

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

A enumeração HierarchyScope, passada como segundo parâmetro do método GetHierarchy, especifica a profundidade da estrutura de bloco de anotações para recuperar. Para recuperar as seções em conjunto com os blocos de anotações, atualize o valor de enumeração para HierarchyScope.hsSections e processar os nós de filho XML adicionais, como demonstrado no do Figura 2.

De enumerando seções, a Figura 2

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

Recuperando e atualizando o conteúdo da página

O método GetPageContent retornará um documento XML que contém todo o conteúdo em uma página especificada. A página para recuperar é especificada usando uma identificação de objeto do OneNote, um identificador exclusivo com base em cadeia de caracteres de cada objeto na hierarquia do bloco de anotações do OneNote. Esta identificação de objeto é incluída como um atributo em todos os nós XML retornado pelo método GetHierarchy.

A Figura 3 se baseia nos exemplos anteriores, usando o método de GetHierarchy para recuperar a hierarquia de bloco de anotações do OneNote para baixo para o escopo de página. Ele usa o LINQ para XML, em seguida, selecione o nó para a página chamado “ Test página ” e passar o ID de objeto da página para o método GetPageContent. O documento XML que representa o conteúdo da página, em seguida, é impresso ao console.

De Obtendo conteúdo da página, a Figura 3

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

O método UpdatePageContent pode ser usado para fazer alterações em uma página. O conteúdo da página é especificado pelo mesmo esquema de documento XML que o código de do Figura 3 recuperado, ele pode conter vários elementos de conteúdo que definem os contornos de texto, arquivos inseridos, imagens, tinta e os arquivos de áudio ou vídeo.

O método UpdatePageContent trata os elementos no documento XML fornecido como um conjunto de conteúdo pode ter sido alterado, a correspondência de conteúdo especificado ao conteúdo existente, o OneNote por meio de identificação de objeto. Portanto, você pode fazer alterações ao conteúdo existente, chamando o método GetPageContent, tornando as alterações desejadas para o XML retornado, em seguida, passar esse XML de volta para o método UpdatePageContent. Você também pode especificar os elementos de conteúdo novos a ser adicionado à página.

Para ilustrar isso, o do Figura 4 adiciona um carimbo de data na parte inferior da nossa página de teste. Ele usa a abordagem mostrada no do Figura 3 para determinar a identificação de objeto do OneNote da página e, em seguida, usa as classes XDocument e XElement System.XML.LINQ para construir um documento XML que contém o novo conteúdo. Porque a ID de objeto de página especificada no documento coincide com a identificação do objeto de uma página existente, o método UpdatePageContent acrescentará o novo conteúdo à página existente.

Do Conteúdo da página de atualização, a Figura 4

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

A biblioteca de modelo de objeto do OneNote

Não é particularmente difícil interagir com o OneNote dados dessa maneira, mas é um pouco estranho analisar e criar documentos XML para realizar operações de dados básica. É aí que entra o modelo de objeto do OneNote. É uma biblioteca de código gerenciado, que fornece abstrações orientado a objeto através da API do OneNote baseado em COM. A biblioteca é o código-fonte aberto e licenciado sob a licença pública do Microsoft (MS-PL).

O modelo de objeto do OneNote está disponível para download no CodePlex em onom.codeplex.com. A biblioteca foi projetada para o OneNote 2007 e no momento em que você leu isso, os downloads de lançamento devem ser atualizados para fornecer compatibilidade com o OneNote 2010. Caso contrário, você ainda pode usá-la com as seções do OneNote 2007 no OneNote 2010 por fazer o download de código-fonte, removendo a referência de assembly Microsoft.Office.Interop.OneNote existente no projeto OneNoteCore e adicionando uma referência à biblioteca de tipos do Microsoft OneNote 14.0, conforme mostrado anteriormente.

Além de alguns projetos de teste de unidade e o código de exemplo, a solução contém dois projetos de biblioteca de classe: OneNoteCore e OneNoteFramework. A biblioteca OneNoteCore a ponte de Low nível entre a API do OneNote COM e metáforas familiares do Microsoft .NET Framework; ele expõe os valores de retorno real em vez de COM out parâmetros converte COM códigos de erro em exceções .net, expõe um struct OneNoteObjectId e instâncias de XDocument, em vez de cadeias de caracteres não processadas e muito mais. Estudar esse código pode ajudá-lo a compreender como funciona a API do OneNote, mas na maioria dos casos, você não precisará interagir com a biblioteca OneNoteCore diretamente.

A biblioteca de OneNoteFramework fornece abstrações de alto nível dos conceitos do OneNote. Aqui você encontrará classes com nomes intuitivos como OneNoteNotebook, OneNoteSection e OneNotePage. O ponto de entrada principal para a interação com a estrutura hierárquica do OneNote é uma classe chamada OneNoteHierarchy, que contém um membro estático denominado atual. Adicionando uma referência de assembly para a biblioteca OneNoteFramework, nós pode reescrever a nosso programa de enumerar os nomes de bloco de anotações ( do Figura 1) maneira muito mais concisa da seguinte maneira:

using Microsoft.Office.OneNote;

class Program
{
  static void Main(string[] args)
  {
    foreach (var notebook in OneNoteHierarchy.Current.Notebooks)
      System.Console.WriteLine(notebook.Name);
  }
}

Como você poderia esperar, a classe OneNoteNotebook tem uma propriedade chamada seções. Portanto, você pode enumerar os nomes de seção ( do Figura 2) simplesmente da seguinte maneira:

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

Coleções expostas pelas propriedades de modelo de objeto do OneNote são gerenciadas com a classe de coleção genérica especializado chamada OneNoteObjectCollection <T>. Como OneNoteObjectCollection <T> implementa IList <T>, bem como IEnumerable <T>, essas coleções podem ser consultadas usando o LINQ.

Por exemplo, dada uma referência a uma instância de OneNoteSection na variável de seção, nós poderia determinar todas as páginas que havia sido modificadas hoje em dia com uma expressão do LINQ simples como este:

var pagesModifiedToday = from page in section.Pages 
                           where page.LastModifiedTime >= DateTime.Today 
                           select page;

Ligação de dados com a biblioteca de objetos do OneNote do modelo

O fato de que o modelo de objeto do OneNote expõe coleções IEnumerable também permite a vinculação de dados baseada em XAML com o Windows Presentation Foundation (WPF). A Figura 5 d demonstra o uso de ligação de dados para exibir uma TreeView do WPF da hierarquia do bloco de anotações do OneNote puramente na marcação XAML — sem exigir o uso de code-behind.

De vinculação de dados com o Windows Presentation Foundation, a Figura 5

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

Esse XAML primeiro faz referência o assembly OneNoteFramework, dando-o de onf do prefixo de namespace XML.Com essa referência in-loco, o DataContext de TreeView pode ser definido para a propriedade Current estática de classe OneNoteHierarchy, fornecendo o controle com a raiz da estrutura da hierarquia do OneNote.HierarchicalDataTemplates são usadas para vincular dados cada nível da árvore com a coleção correspondente de expostos pelo modelo de objeto do OneNote (consulte do Figura 6).

image: Data Binding the Hierarchy to a Tree View

Figura 6 de vinculação de dados para um modo de exibição de árvore de hierarquia

Acesso simplificado a dados

Quebra automática de, a biblioteca de modelo de objeto do OneNote simplifica substancialmente o acesso a dados em blocos de anotações do Microsoft OneNote, expondo as coleções de objeto avançado que podem ser consultadas e manipuladas com expressões de LINQ e vinculação de dados do WPF.Um artigo de acompanhamento será estender esses conceitos para explorar trabalhando com blocos de anotações do OneNote em aplicativos do Silverlight e o telefone do Windows e acessar os dados do OneNote na nuvem.

Andy Gray é um diretor de tecnologia do parceiro e do software de cinco talentos, ajudando a organizações sem fins lucrativos que operam com mais eficiência através de tecnologia estratégica soluções. Ele escreve sobre o desenvolvimento do OneNote em onenotedev.com de .

Graças aos seguintes especialistas técnicos para revisão deste artigo: Michael Gerfen e Guin. John