por Ben Waldron

As smart tags foram introduzidas primeiramente no Microsoft® Office XP como uma maneira integrada de permitir que os usuários apresentassem dinamicamente informações adicionais em seus documentos. Para os usuários gerais do Office, as smart tags representam uma maneira de alavancar a produtividade por meio de ações vinculadas a palavras-chave. Para os usuários corporativos, as smart tags são usadas para associar os usuários aos recursos internos com base no tipo de dados que eles exibem ou incluem nos aplicativos Office. Um bom exemplo consiste em vincular um número de ordem de compra em uma planilha do Excel a informações detalhadas sobre uma venda a partir de uma fonte da intranet da empresa. Para os desenvolvedores, as smart tags representam uma nova maneira de vincular serviços orientados a informações aos aplicativos utilizados com mais freqüência pelos clientes.

Fiz uma pesquisa entre os desenvolvedores de minha comunidade e descobri que a maioria deles reconhecia as vantagens das smart tags mas não havia ainda se disposto a dar os primeiros passos para desenvolvê-las ou para usar o Microsoft .NET Framework para isso. Embora muitos desenvolvedores estejam animados com a perspectiva de criar smart tags gerenciadas, o desenvolvimento de smart tags com o .NET não recebeu a devida atenção.

Neste artigo, demonstrarei como desenvolver smart tags. Abordarei tópicos como o uso do esquema XML MOSTL (Microsoft Office Smart Tag List) para desenvolver smart tags de forma rápida e eficaz, bem como o uso do .NET Framework para criar smart tags gerenciadas mais avançadas para o Office 2003 e Office XP. Em seguida, falarei sobre como implementar esses recursos na sua organização.

História das Smart Tags

As smart tags entraram em cena no Office XP, com amplo suporte no Word, Excel e Microsoft Outlook® (quando o Word é usado como um editor de e-mails, que é o padrão). O Microsoft Internet Explorer versões 5.0 e superior suportam smart tags em uma maneira diferente da dos aplicativos do Office. Nessas versões do Internet Explorer, o texto não é reconhecido automaticamente pelas smart tags; no entanto, é possível adicionar tags HTML personalizadas ao arquivo de origem HTML para permitir o reconhecimento do texto no qual você deseja utilizar uma smart tag. Nesta primeira iteração, as smart tags do Office XP foram desenvolvidas com a Biblioteca de Tipos do Microsoft Smart Tag 1.0.

A simplicidade das smart tags é o que as torna tão avançadas. A smart tag precisa primeiro reconhecer os dados de acordo com algum critério importante e, em seguida, apresentar ao usuário uma lista de menu com as ações relevantes a esses dados. Quando o usuário faz uma seleção, é realizada uma ação de menu apropriada. A smart tag é composta de duas classes COM. Uma classe de reconhecimento (Recognizer) é responsável por fazer a correspondência dos dados passados por um aplicativo habilitado para smart tags; uma classe de ação (Action) informa ao aplicativo os itens de menu a serem exibidos e executa uma ação quando o aplicativo sinaliza a ação a ser realizada. A interação geral entre o aplicativo e essas classes é mostrada na Figura 1.

Figura 1. Interfaces Smart Tag

Com base no feedback dos consumidores, a Microsoft fez melhorias nas smart tags na versão do Office 2003. O número de aplicativos que oferecem suporte a smart tags foi expandido para incluir o Microsoft PowerPoint® e o Microsoft Access. Além de um suporte mais amplo aos aplicativos, as próximas interações de smart tags incluem algumas opções melhores de utilização. No Office XP, as smart tags suportavam apenas um nível de menus quando exibidas, mas agora foram incluídos menus em cascata para agrupar as ações dentro do menu da smart tag. A capacidade de controlar o período de tempo em que as smart tags estão ativas e permitir que os usuários as desativem a partir de uma única janela de configuração também foi incluída no Office 2003. Outro recurso que os desenvolvedores solicitaram foi a capacidade de saber qual aplicativo está chamando a smart tag. Isto permite que você trate o reconhecimento e as ações de uma maneira quando a solicitação vier do Word e de outra maneira se ela vier do Excel. Para obter uma lista completa dos novos recursos de smart tag do Office 2003, vá para What's New with Smart Tags in Office 2003 (http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnofftalk/html/office01022003.asp).

A Microsoft Smart Tags 2.0 Type Library, que é usada para desenvolver smart tags para o Office 2003, é totalmente compatível com as versões anteriores do Office XP. Todos os recursos que existiam no Office XP funcionarão com as smart tags desenvolvidas com a nova biblioteca de tipos, o que é excelente para organizações que rodam tanto o Office XP como o Office 2003.

Esquema MOSTL

As smart tags simples que temos em mente envolvem o reconhecimento de uma palavra e associação desta a um site Web. A criação desse tipo de smart tag é tão simples como construir um arquivo XML. No Office XP e no Office 2003, existe uma biblioteca denominada MOFL.dll (C:\Program Files\Common Files\Microsoft Shared\Smart Tag\MOFL.dll) que permite que os desenvolvedores criem arquivos XML em conformidade com o esquema MOSTL para criar as tags sem precisar usar códigos.

O esquema MOSTL é usado quando você quer desenvolver smart tags que reconheçam modelos ou palavras bem definidas e que, a partir daí, executem ações relativamente simples. Um novo recurso do Office 2003 permite que os desenvolvedores usem expressões regulares para reconhecer um padrão em vez de apenas uma lista de termos. Por exemplo, é possível escrever uma smart tag que possa reconhecer um endereço IP e que desenvolva uma ação que vá para uma lista de Web site que seja dono de tal endereço. Embora isso não seja muito prático para um usuário comercial, serve para ilustrar a potência do MOSTL combinado com as expressões regulares. Esse tipo de reconhecimento de padrão pode ser usado em muitos negócios, já que os códigos formatados de maneira exclusiva são geralmente usados para números de pedidos, números de rastreamento e outros identificadores. O XML MOSTL que executa ação e reconhecimento de endereços IP é mostrado na Listagem 1.

Listagem 1 Reconhecendo um endereço IP

<FL:smarttaglist xmlns:FL="urn:schemas-microsoft-com:smarttags:list">
  <FL:name>WhoIs IP Lookup</FL:name>
  <FL:lcid>1033,0</FL:lcid>
  <FL:description>Lookup up a domain name</FL:description>
  <FL:moreinfourl>http://msdn.microsoft.com/msdnmag</FL:moreinfourl>
  <FL:updateable>false</FL:updateable>
  <FL:autoupdate>false</FL:autoupdate>
  <FL:lastcheckpoint>0</FL:lastcheckpoint>
  <FL:lastupdate>0</FL:lastupdate>
  <FL:updateurl></FL:updateurl>
  <FL:updatefrequency>0</FL:updatefrequency>
  <FL:smarttag type="urn:schemas-microsoft-com:office:smarttags#whois">
    <FL:caption>WhoIs IP Search</FL:caption>
      <FL:re>    
        <FL:exp>\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-
          9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b</FL:exp>
      </FL:re>
    <FL:actions>
      <FL:action id="WhoIs">
        <FL:caption>Find WhoIs for IP</FL:caption> 
        <FL:url>http://ws.arin.net/cgi-bin/whois.pl?queryinput={TEXT}
        </FL:url>
      </FL:action>
    </FL:actions>
  </FL:smarttag>
</FL:smarttaglist>

O XML produzido para uma smart tag deve obedecer estritamente ao esquema MOSTL e ser um documento XML válido. Isso significa que todos os caracteres dentro do XML devem ser apropriadamente fechados. O início do esquema MOSTL configura a smart tag de modo que ela seja reconhecida como uma smart tag válida, definindo a localidade e criando a habilidade de atualizar a smart tag a partir de um site Web em alguma freqüência. As tags XML mais importantes criam a expressão regular a ser reconhecida e também a ação a ser executada quando o usuário clica em uma determinada ação da smart tag. Nesse caso, quando um endereço IP é reconhecido e o usuário clica na ação "Find WhoIs for IP" na smart tag, elas são enviadas para o registry WhoIs daquele endereço IP específico, conforme mostrado na Figura 2.

Figura 2. Tag

O esquema XML MOSTL é a maneira mais rápida de criar smart tags. Implementar uma nova smart tag envolve copiar o arquivo XML para o local onde o Office está instalado. Por padrão, copiar o arquivo em C:\Program Files\Common Files\Microsoft Shared\Smart Tag\LISTS ou em um subdiretório de uma localidade específica o tornará disponível a um usuário. Isso pode ser feito por meio de um aplicativo de instalação, de uma política de grupo ou por meio de um serviço de atualização de software, como o Microsoft System Management Service.

Criando uma Biblioteca de Smart Tags

Muitas vezes, não é tão fácil associar os dados reconhecidos à ação apropriada, e é possível que o desenvolvedor precise adicionar mais lógica de programação do que a fornecida pelo esquema MOSTL. Conforme mencionado anteriormente, a maioria dos negócios utiliza os identificadores exclusivos para ordens de compra, rastreamento de entregas ou venda de produtos. Na maior parte dos casos, associar esses identificadores a informações sugestivas exige que se obtenha informações de múltiplas fontes e, para ser mais compensador, que se agregue os dados para o usuário. Um usuário com um identificador de ordem de vendas pode rapidamente ver o cliente, o preço pago, as informações de envio e o histórico da compra sem precisar sair do Office. Nesse tipo de caso, é necessário criar uma biblioteca que implemente as interfaces necessárias para a criação de uma smart tag. Criar uma smart tag simples envolve implementar as interfaces definidas e, assim como em qualquer projeto de software, torna-se mais complicado à medida que requer mais lógica para executar as funções avançadas. A criação de uma smart tag gerenciada permite que os desenvolvedores aproveitem as vantagens de todos os recursos do .NET Framework com os quais estejam acostumados.

Antes de criar uma biblioteca de smart tags, gostaria de descrever a funcionalidade em meu exemplo de biblioteca de smart tags. Sou fã da liga nacional de beisebol e, por esse motivo, seria útil reconhecer os termos relacionados às equipes. Uma vez reconhecidos esses termos, posso associá-los a vário Web sites para mostrar a posição da equipe, as médias e outras informações que um fã de beisebol gostaria de ver. Essa smart tag precisará ter alguma lógica interna para determinar a equipe correta à qual ela se associará. Por exemplo, se eu correlacionar a palavra "Sox" na smart tag, precisarei dar aos usuário escolhas para o site Chicago White Sox ou Boston Red Sox.

Essa smart tag da liga nacional de beisebol será escrita com o Visual Studio® .NET 2003. A primeira etapa para criar uma smart tag gerenciada é criar um novo projeto de biblioteca de classes (Class Library) e adicionar uma referência ao COM Microsoft Smart Tags 2.0 Type Library, mostrado na Figura 3.

Figura 3. Lista de Microsoft Smart Tags 2.0 Type Library List

A inclusão dessa referência permite criar smart tags tanto para o Office 2003 como para o Office XP. Referenciar essa biblioteca automaticamente prepara a biblioteca COM para ser usada pelo .NET Framework sem exigir que o desenvolvedor faça nenhum trabalho adicional. A biblioteca que será produzida precisa ser registrada para interoperabilidade COM (COM Interoperability), e fazer isso no Visual Studio .NET ajudará na depuração e na implementação depois que a biblioteca for produzida.

As duas classes acima mencionadas que são exigidas para a smart tag são a classe recognizer, responsável por reconhecer o texto ou os padrões existentes nos aplicativos que suportam smart tags, e a classe action, que determina os menus que são mostrados ao usuário e a operação apropriada que corresponde a um item de menu. Primeiramente, explicarei como desenvolver uma classe recognizer e, em seguida, criarei a classe action.

Classe Recognizer

A classe recognizer faz interface com a infra-estrutura da smart tag por meio do COM e, por isso, é necessário adicionar o namespace System.Runtime.InteropServices para incluir os atributos necessários para integração do COM com aplicativos baseados em .NET. O namespace Microsoft.Office.Interop.SmartTag também é importado de modo que minha classe Msdn.MlbSmartTag.Recognizer possa facilmente implementar as interfaces apropriadas, conforme mostrado aqui:

using System;
using System.Runtime.InteropServices;
using Microsoft.Office.Interop.SmartTag;

namespace Msdn.MlbSmartTag
{
    [ProgId("MlbSmartTag.Recognizer")]
    [GuidAttribute("90D62E8D-79E3-4197-907F-BF3EC133698D")]
    [ComVisible(true)]
    public class Recognizer : ISmartTagRecognizer2, ISmartTagRecognizer
    ...

Existem três importantes atributos que podem decorar minha classe Recognizer. O atributo ProgId permite que você especifique o identificador programático que pode ser usado quando a classe for registrada com o COM. Mais importante, porém, é o atributo GuidAttribute, que forma uma ID de classe exclusiva (CLSID) para a classe. Quando implementar a biblioteca, é possível usar o ProgId ou o CLSID para registrar a interface, mas é recomendável que você use o CLSID para evitar um problema no Office XP no qual o flag de status não seja atualizado durante o registro da interface com o ProgId. O atributo ComVisible é adicionado à classe para garantir que ela possa ser vista como um tipo no COM.

Uma classe recognizer precisa implementar as interfaces ISmartTagRecognizer2 e ISmartTagRecognizer. O Visual Studio .NET incluirá os stubs para implementar as interfaces necessárias, o que torna muito fácil preencher a lógica necessária para completar a classe recognizer.

A Tabela 1 mostra uma lista completa das propriedades e métodos para implementar as interfaces de uma classe recognize válida. A propriedade SmartTagName é usada para identificar de forma exclusiva a classe recognizer, bem como para funcionar como uma chave de ação quando o texto é reconhecido e enviado à classe action correspondente. Para formar SmartTagName, utiliza-se um namespace URI e, em seguida, adiciona-se o nome da smart tag separado por um sinal de libra esterlina. Neste exemplo, a SmartTagName é urn:schemas-microsoft-com:msdnmag#mlb. É importante que esse nome não entre em conflito com o nome de nenhuma outra SmartTag que esteja implementada no mesmo ambiente. Ele também é muito importante durante a criação de uma classe action, já que funciona como a "cola" que liga a classe de reconhecimento à classe de ação. Esses nomes devem ser iguais; caso contrário, as duas classes não serão associadas de forma apropriada.

Tabela 1 Propriedades e métodos Recognizer

É importante lembrar que todas as classes .NET acessíveis ao COM precisam fornecer um construtor padrão; ou seja, um construtor que não exige nenhum parâmetro. As funções de criação de objeto COM não passam parâmetros para os objetos por elas criados, por isso você precisa garantir que o construtor padrão esteja presente.

O método SmartTagInitialize é usado para executar todas as inicializações necessárias quando a classe recognizer da smart tag é carregada. No exemplo, a lista de nomes de equipe é inicializada no array e funcionará como os termos que deverão ser reconhecidos. É necessário mencionar que existem muitas outras maneiras de reconhecer os termos além de uma simples lista de tokens. As expressões regulares são geralmente usadas para coincidir padrões como identificadores exclusivos, enquanto a programação lógica pode ser usada para recuperar os dados ou para determinar outros critérios de correspondência. Um bom exemplo disso é o Person Name Smart Tag que é incluído no Office. Essa smart tag recupera uma lista de nomes do Outlook Contacts para reconhecimento e permite que o usuário envie rapidamente um e-mail, programe um compromisso, ou veja se determinado usuário está on-line no momento. Ao executar esse tipo de recuperação de informações e de configuração em SmartTagInitialize, é possível melhorar o desempenho da classe recognizer da smart tag, já que ela pode acessar os dados no cache em vez de precisar pesquisá-los a cada solicitação de reconhecimento.

O método Recognize2 (consulte Listagem 2) é onde reside a maior parte da responsabilidade dessa classe. A aplicativo que chama passa a esse método o texto a ser reconhecido, a localidade e o tipo de dado onde o texto foi encontrado no aplicativo. O tipo de dado é baseado no contexto do texto. O tipo seria IF_TYPE_CELL se fosse encontrado dentro de uma célula no Excel, e IF_TYPE_PARA se estiver dentro de um parágrafo no Word. Também foram adicionados novos parâmetros que não existiam no método Recognize original. O nome do aplicativo que chama permite que a classe recognizer faça um reconhecimento alternativo com base no aplicativo, e foi adicionada uma lista com os tokens dos itens de texto para ajudá-lo a desenvolver os algoritmos de correspondência.

Listagem 2 Implementação da classe Recognizer

public class Recognizer : ISmartTagRecognizer2, ISmartTagRecognizer 
{
  private string[] terms;
  private int termCount;

  /// construtor padrão - nenhum parâmetro para COM Interop
  public Recognizer(){}

  public void Recognize2(
    string Text, IF_TYPE DataType, int LocaleID, 
    ISmartTagRecognizerSite2 RecognizerSite2, string ApplicationName, 
    ISmartTagTokenList TokenList) 
  {          
    for (int i=1; i<=TokenList.Count; i++) 
    {
      // obtenha o token
      ISmartTagToken token = TokenList.get_Item(i);
 
      // faça a correspodência do token para cada termo
      foreach (string term in terms) 
      {
        if (token.Text.ToLower() == term.ToLower()) 
        {
          ISmartTagProperties propertyBag  = 
            RecognizerSite2.GetNewPropertyBag();

          // valide o token como um termo reconhecido
          RecognizerSite2.CommitSmartTag2(
            "urn:schemas-microsoft-com:msdnmag#mlb", 
            token.Start, token.Length, propertyBag);
        }
      }
    }
  }

  public void SmartTagInitialize(string ApplicationName)
  {
    terms = new string[] {
        "Cubs", "Cardinals", "Astros", 
        "Yankees", "Pirates", "Angels", "Sox"
    };
    termCount = terms.Length;
  }

  public string get_SmartTagName(int SmartTagID) 
  {
    return "urn:schemas-microsoft-com:msdnmag#mlb";
  }

  public string ProgId { get{ return "MlbSmartTag.Recognizer"; } }
}

O método Recognize2 percorre todo o texto dos tokens passados a ele pelo aplicativo que chama para tentar encontrar uma correspondência. Caso encontre uma correspondência, será criado um recipiente de propriedades de smart tag para permitir que você adicione mais propriedades ao texto que está sendo correspondido. O RecognizerSite2 é responsável por fazer a interface com o aplicativo que chama. O método CommitSmartTag2 passa a caixa de propriedades e a localidade onde o reconhecimento ocorreu no aplicativo. Uma chamada a esse método faz com que o aplicativo chame a classe Action correspondente juntamente com a caixa de propriedades para exibir o menu que lista as ações possíveis.

Classe Action

A criação de uma classe Msdn.MlbSmartTag.Action é semelhante à criação de minha classe Recognizer. A Listagem 3 mostra as propriedades e métodos mais importantes necessários para criar a classe Action. Os mesmos namespaces são necessários para tornar a classe acessível ao COM e para usar as interfaces de smart tag. É importante observar que o ProgId e o GuidAttribute não devem ser iguais aos valores em minha classe Recognizer (afinal, elas são classes COM diferentes), por isso é necessário criar um novo identificador exclusivo que será o CLSID da classe Action.

Listagem 3 Classe Action

public class Action : ISmartTagAction2, ISmartTagAction 
{
  public bool get_ShowSmartTagIndicator(
    int VerbID, string ApplicationName, int LocaleID) 
  {
    return true;  // mostre o indicador de sublinhado
  }

  public int get_VerbCount(string SmartTagName) 
  {
    if (SmartTagName == "urn:schemas-microsoft-com:msdnmag#mlb") 
      return 4;  // existem quarto ações possíveis
    else
      return 0;
  }

  public bool get_IsCaptionDynamic(
    int VerbID, string ApplicationName, int LocaleID) 
  {
    return true;  // a legenda é alterada com base no nome da equipe
  }

  public string get_VerbCaptionFromID2(
    int VerbID, string ApplicationName, int LocaleID, 
    ISmartTagProperties Properties, string Text, 
    string Xml, object Target) 
{            
    string captionText = string.Empty;
    switch (VerbID) 
    {
      case 1:
        if (Text == "Sox")
          captionText = "MLB///Go to Red Sox website";
        else
          captionText =  String.Format("MLB///Go to {0} website", Text);
        break;
      case 2:
        if (Text == "Sox")
          captionText = "MLB///Go to White Sox website";
        break;
      case 3:
        captionText = "MLB///Show Standings";
        break;
      case 4:
        captionText = "MLB///Show Schedule";
        break;
    }
    return captionText;
  }

  public void InvokeVerb2(
    int VerbID, string ApplicationName, object Target, 
    ISmartTagProperties Properties, string Text, 
    string Xml, int LocaleID) 
{
    ProcessStartInfo startInfo = new ProcessStartInfo("iexplore.exe");
    switch (VerbID) 
    {
      case 1:
        if (Text == "Sox") 
          startInfo.Arguments = "http://www.redsox.com";
        else 
          startInfo.Arguments = String.Format("http://www.{0}.com", Text);
        break;
      case 2:
        startInfo.Arguments = "http://www.whitesox.com";
        break;
      case 3:
        startInfo.Arguments = "http://msn.foxsports.com/mlb/standings";
        break;
      case 4:
        startInfo.Arguments = "http://msn.foxsports.com/mlb/schedule";
        break;
    }
    if (startInfo.Arguments != string.Empty)
      Process.Start(startInfo);
  }

  public string get_SmartTagName(int SmartTagID) 
  {
    return "urn:schemas-microsoft-com:msdnmag#mlb";
  }
}

A classe Action implementa duas interfaces a partir da biblioteca Smart Tag 2.0 Type: ISmartTagAction2 e ISmartTagAction. Assim como na classe recognizer, todas as propriedades e métodos são obrigatórios, e o Visual Studio .NET gerará stubs ao adicionar as interfaces à declaração de classe, conforme mostrado aqui:

using System;
using System.Runtime.InteropServices;
using Microsoft.Office.Interop.SmartTag;

namespace Msdn.MlbSmartTag
{
  [ProgId("MlbSmartTag.Action")]  
  [GuidAttribute("63CB4201-3387-47c3-B0B2-0CCF56BB892D")]
  [ComVisible(true)]
  public class Action : ISmartTagAction2, ISmartTagAction
  ...

A Tabela 2 lista as propriedades e os métodos usados por uma classe Action. Algumas propriedades são as mesmas encontradas na classe recognizer, mas existem algumas que exigem mais atenção. Conforme mencionei na discussão sobre a classe recognizer, o valor da propriedade SmartTagName precisa ser igual na classe Action e na sua classe Recognizer correspondente, de modo que o aplicativo que chama possa encaminhar a solicitação ao handler de ação apropriado.

Tabela 2 Propriedades e métodos da classe Action da Smart Tag

A propriedade ShowSmartTagIndicator é usada para determinar se o indicador de sublinhado deve ser mostrado para sinalizar ao usuário de que a smart tag foi reconhecida e possui ações associadas a ela. Geralmente, essa propriedade é sempre definida como true, mas com base no aplicativo ou localidade que chama, ela pode ser definida para não mostrar o indicador.

A propriedade VerbCount é definida como o número máximo de ações que a smart tag exibirá. No exemplo, é utilizado um simples check para assegurar que a smart tag correta está chamando essa propriedade e, em seguida, é retornado o valor 4 porque o menu Smart Tag Action possui quatro ações possíveis.

A propriedade VerbCaptionFormID2 realiza uma quantidade significativa de trabalho para uma classe action. Com base no valor definido na propriedade VerbCount, essa propriedade é chamada repetidamente, cada vez com um VerbID diferente. Ela é responsável por criar o texto que será exibido no menu Smart Tag Action. Os menus em cascata são um novo recurso do Office 2003. O uso do delimitador "///" no texto que é retornado pela propriedade distribuirá o texto em submenus.

Na primeira vez que a propriedade VerbCaptionFromID2 for chamada, o valor de VerbID será 1, e será chamada a instrução case apropriada. É importante notar que, se você estiver usando VerbIndex como o VerbID (como no exemplo), o índice de início de VerbIndex será 1 (em vez de 0). Isso é algo que pode causar problemas para os usuários acostumados a desenvolver principalmente no .NET Framework. A lógica personalizada é incorporada a essa propriedade para lidar com os casos em que a palavra "Sox" é reconhecida. Isso acontece porque não sabemos se o usuário queria fazer a correspondência com Boston Red Sox ou com Chicago White Sox.

A propriedade IsCaptionDynamic entra em jogo quando o menu que é exibido ao usuário é alterado em função de algum valor. Se os menus da ação não forem alterados, essa propriedade deverá ser definida como false. Neste exemplo, exibimos um menu diferente com base no que foi reconhecido, por isso a propriedade é definida como true. Esses menus dinâmicos são uma das razões de a smart tag estar sendo criada como uma biblioteca, em vez de usar o esquema MOSTL.

O ponto crucial para uma smart tag é quando o usuário clica em um item de menu para chamar uma ação. Essa ação é tratada pelo método InvokeVerb2 e é onde os desenvolvedores podem fornecer a potência para fazer coisas interessantes. O VerbID, o nome do aplicativo, o recipiente de propriedades e o texto reconhecido são passados para este método. Novo no método InvokeVerb2 é a localização, para que os desenvolvedores possam criar mais facilmente aplicativos em vários idiomas.

O exemplo de InvokeVerb2 é relativamente objetivo e representa um bom exemplo. Com base no item de menu que o usuário selecionou, um navegador abrirá a página da Web apropriada. O usuário que digitar "Cubs" ou "Chicago Cubs" poderá navegar rapidamente até seus status correspondentes. (Se eles forem tão fãs do Cubs quanto eu, certamente ficarão desapontados - assunto muito comum entre nós, fãs do Cubs.)

Existem numerosas outras ações que podem ser executadas quando um usuário clica em uma classe action da smart tag. O uso do .NET Framework para criar a smart tag aumenta essas possibilidades ao permitir que você faça praticamente qualquer coisa que costume fazer no .NET. Isso inclui chamar Web services, pesquisar um banco de dados e encontrar outras maneiras interessantes de agregar valor aos dados de documentos do Office.

Outro recurso do Office 2003 que complementa as smart tags é o painel Research. Ele fornece aos desenvolvedores um local para exibir informações aos usuários sem precisar sair do Office. As smart tags oferecem um bom link para notificar os usuários de que eles podem ver mais informações no painel Research.

Ferramentas de depuração

Algumas ferramentas lançadas recentemente ajudam os desenvolvedores a depurar e testar smart tags sem precisar testá-las diretamente nos aplicativos Office. O primeiro utilitário, denominado Smart Tag Explorer, permite que os desenvolvedores vejam todas as classes recognizer e action da smart tag que estão configuradas no sistema local. Isso é especialmente útil para assegurar que o registro tenha sido concluído com êxito e que as smart tags estejam ativadas no sistema. Além disso, serve para mostrar quais aplicativos estão configurados para executar as smart tags juntamente a outras configurações, tais como onde procurar por atualizações e a cor do indicador da smart tag.

Outro utilitário é o Smart Tag Recognize Tester. Ele pode ser executado a partir do Smart Tag Explorer e é usado para testar a funcionalidade de reconhecimento. Esse utilitário economiza tempo quando a lógica de reconhecimento é complicada e você quer testar rapidamente o reconhecimento de vários dados. Esses dois utilitários são aplicativos gerenciados, por isso é muito fácil anexá-los a um depurador para percorrer rapidamente o código a ser depurado ou testar a smart tag. É fácil ver como a interface do Smart Tag Recognize Tester, mostrada na Figura 4, pode ser útil na depuração e nos testes através da indicação do texto e dos offsets do reconhecimento. Essas ferramentas podem ser baixadas em Introduction to the Smart Tag Explorer and Smart Tag Recognize Tester (http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dno2k3ta/html/ODC_Managed_SmartTag_Utilities.asp).

Figura 4. Smart Tag Recognize Tester

Implementação

Agora que você desenvolveu a funcionalidade da smart tag, é igualmente importante colocá-la nas mãos dos usuários que precisam dela. Implementar uma smart tag que foi desenvolvida por meio do esquema MOSTL envolve copiar o arquivo XML em todas as máquinas que precisam da smart tag. O MOSTL também permite que você defina a freqüência e o local de onde as atualizações podem ser baixadas em um Web site.

Já a implementação de bibliotecas de smart tags não é tão simples porque a biblioteca precisa ser registrada e é necessário criar as chaves de registro do Windows para permitir que o aplicativo saiba que a smart tag existe. Criar uma biblioteca de smart tags gerenciada permite que se modifique o registro usando o ComRegisterFunctionAttribute quando a biblioteca é registrada por meio do aplicativo Register Assembly (regasm.exe).

São necessárias apenas duas chaves de registro para a execução da smart tag: uma para a classe recognizer (HKEY_CURRENT_USER\Software\Microsoft\Office\ Common\ Smart Tag\Recognizers\{CLSID}) e uma para a classe action (HKEY_CURRENT_USER\Software\Microsoft\Office\ Common\Smart Tag\Actions\{CLSID}). O identificador exclusivo criado para cada classe é colocado na subchave apropriada. O código na Listagem 4 demonstra como assegurar que essas chaves corretas sejam colocadas no registro da classe recognizer quando a biblioteca for registrada. Ela mostra também a UnregisterFunction para quando a biblioteca for desregistrada.

Listagem 4 Adicionando e excluindo chaves de Smart Tags

// chaves de registro
static readonly string clsId = "90D62E8D-79E3-4197-907F-BF3EC133698D";
static readonly string recognizersKey = "SOFTWARE\\Microsoft\\Office" +
  "\\Common\\Smart Tag\\Recognizers\\{" + clsId + "}";
    
// Instale chaves de registro para tornar a classe recognizer disponível aos aplicativos
[ComRegisterFunction]
public static void RegisterFunction(Type type) 
{
  // crie chaves de registro para a classe recognizer
  using(RegistryKey regHkcu =
    Registry.CurrentUser.CreateSubKey(recognizersKey))
  {
    regHkcu.SetValue(null, string.Empty);
  }
}

// Desinstale as chaves de registro
[ComUnregisterFunction]
public static void UnregisterFunction(Type type) 
{
  Registry.CurrentUser.DeleteSubKey(recognizersKey);
}

Ter as chaves de registro aplicadas quando a biblioteca é registrada simplifica a implementação. Há diversas maneiras de copiar a biblioteca nos clientes e de registrá-la. A primeira é criar uma instalação para a biblioteca de smart tags e permitir que os usuários a instalem por conta própria. Outras maneiras incluem implementar a biblioteca por meio de uma política de grupo ou de outros aplicativos de atualização de software existentes no ambiente para o qual você está desenvolvendo.

Embora o registro de smart tags gerenciadas para COM interop seja uma excelente maneira de colocá-las ativas e em execução, os desenvolvedores são orientados veementemente a isolar suas smart tags gerenciadas de outros suplementos (add-ins) gerenciados do Office. O .NET permite o isolamento por meio de domínios de aplicativos, e carregar cada smart tag em um domínio de aplicativo individual aumentará a estabilidade geral do aplicativo host. O Office 2003 possibilita essa separação através do Microsoft Visual Studio Tools for the Microsoft Office System loader. Ele é fácil de usar e representa a maneira correta de implementar smart tags gerenciadas. Além disso, o Visual Studio Tools for Office loader otimiza o modelo de segurança do .NET, fornecendo uma segurança mais firme para os add-ins gerenciados. Para obter mais informações sobre projeto, desenvolvimento e implementação de add-ins do Office XP e do Office 2003 implementadas com o .NET Framework, consulte Information about designing Office XP add-ins and Office 2003 add-ins by using the .NET Framework e Support for Managed-Code Smart Tags. Além disso, a documentação Isolating Office Extensions with the COM Shim Wizard descreve outra maneira de implementar isolamento de domínio de aplicativo através do uso de um C++ shim.]

Segurança

Ao criar uma smart tag desenvolvida com o .NET Framework no Office XP, a biblioteca estava sujeita às verificações de segurança do Office baseadas em uma assinatura digital. Infelizmente, o mecanismo de runtime do .NET (Mscoree.dll) não é assinado digitalmente para o Office. Isso significa que os usuários podiam ver uma caixa de diálogo de segurança de macro quando utilizassem smart tags. A alternativa do Office XP foi desenvolver um unmanaged shim para chamar o componente .NET.

No Office 2003, não é mais necessário desenvolver um unmanaged shim porque o Office 2003 permite que smart tags e outros add-ins gerenciados sigam a política de segurança do .NET, em vez de as verificações de segurança do Office. O Visual Studio Tools for Office loader, que está incluído no Office 2003, carrega a smart tag gerenciada e está sujeito às verificações de segurança do Office em vez de managed code, o que é outra boa razão para começar a criar smart tags gerenciadas.

Conclusão

Há muitos usos produtivos para as smart tags, e as tags são facilmente criadas por meio do esquema MOSTL. O uso do .NET Framework para criá-las torna mais fácil associar de maneira rápida e intuitiva os usuários do Office aos dados externos. Da mesma forma, a criação de smart tags gerenciadas simplifica sua distribuição aos usuários que delas necessitam.

Ben Waldron (bwaldron@microsoft.com) é consultor-sênior da Microsoft Consulting Services e fornece orientação de arquiteturas e soluções de desenvolvimento para clientes do governo federal. Ele está estabelecido em Washington, D.C.