Chamar código nos suplementos de nível de aplicativo de outras soluções do Office

Artigo
02/25/2013

Você pode expor um objeto no suplemento a outras soluções, incluindo outras soluções do Office.Isso é útil se o suplemento fornece um serviço que você deseja ativar outras soluções para usar.Por exemplo, se você tiver um suplemento para o Microsoft Office Excel que executa cálculos financeiros de dados em um serviço da Web, outras soluções podem executar os cálculos no suplemento chamando o excel em tempo de execução.

Aplicável a: As informações neste tópico se aplicam a projetos em níveis de aplicativo o Microsoft Office 2013 e o Microsoft Office 2010. Para obter mais informações, consulte Recursos disponíveis pelo aplicativo do Office e o tipo de projeto.

Há duas principais etapas em esse processo:

Em o suplemento, expõe um objeto para outras soluções.
Em outra solução, acessar o objeto expõe pelo suplemento, e chamar membros do objeto.

Tipos de soluções que podem chamar código em um suplemento

Você pode expor um objeto em um suplemento aos seguintes tipos de soluções:

Código do Visual Basic é Applications (VBA) em um documento que é carregado no mesmo processo do aplicativo que o suplemento.
personalizações da nível que são carregadas no mesmo processo do aplicativo que o suplemento.
O outro suplementos criado usando os modelos de projeto do Office no Visual Studio.
Suplementos COM (isto é, suplementos que implementa a interface de IDTExtensibility2 diretamente).
Qualquer solução que está sendo executado em um processo diferente do suplemento (esses tipos de soluções também é chamada clientes fora de processo.)Esses incluem aplicativos que automatizam um aplicativo do Office, como formulários do windows ou aplicativos de console, e suplementos que são carregados em um processo diferente.

Expõe objetos para outras soluções

Para expor um objeto no suplemento a outras soluções, execute as seguintes etapas no suplemento:

Defina uma classe que você deseja expor a outras soluções.
Substituir o método de RequestComAddInAutomationService na classe de ThisAddIn .Retornar uma instância da classe que você deseja expor a outras soluções.

Definindo a classe você deseja expor a outras soluções

Por o menos, a classe que você deseja expor deve ser pública, deve ter o atributo de ComVisibleAttribute definido como true, e deve expor a interface de IDispatch .

A maneira recomendada para expor a interface de IDispatch é execute as seguintes etapas:

Define uma interface que declara os membros que você deseja expor a outras soluções.Você pode definir essa interface em seu projeto do suplemento.Em o entanto, convém definir essa interface em um projeto de biblioteca de classes separado se você deseja expor a classe para soluções de não VBA, de modo que as soluções que chama o suplemento possam fazer referência a interface sem referênciar o projeto do suplemento.
Aplique o atributo de ComVisibleAttribute a essa interface, e defina este atributo a true.
Altere sua classe para implementar essa interface.
Aplique o atributo de ClassInterfaceAttribute a sua classe, e defina o atributo para o valor de None de enumeração de ClassInterfaceType .
Se você deseja expor a classe para clientes fora de processo, você também pode precisar fazer o seguinte:
- A classe deriva de StandardOleMarshalObject.Para obter mais informações, consulte Expondo classes para clientes fora de Processo.
- Defina a propriedade de Registrar para Interoperabilidade COM no projeto onde você define a interface.Isso é necessário somente se você deseja permitir que clientes para usar associação inicial para chamar o suplemento.Para obter mais informações, consulte Gerenciar propriedades de compilação.

O exemplo de código a seguir demonstra uma classe de AddInUtilities com um método de ImportData que pode ser chamado por outras soluções.Para ver este código no contexto de um maior passo a passo, consulte Passo a passo: Chamando o código de um suplemento em nível de aplicativo do VBA.

<ComVisible(True)> _
Public Interface IAddInUtilities
    Sub ImportData()
End Interface

<ComVisible(True)> _
<ClassInterface(ClassInterfaceType.None)> _
Public Class AddInUtilities
    Implements IAddInUtilities

    ' This method tries to write a string to cell A1 in the active worksheet.
    Public Sub ImportData() Implements IAddInUtilities.ImportData

        Dim activeWorksheet As Excel.Worksheet = Globals.ThisAddIn.Application.ActiveSheet

        If activeWorksheet IsNot Nothing Then
            Dim range1 As Excel.Range = activeWorksheet.Range("A1")
            range1.Value2 = "This is my data"
        End If
    End Sub
End Class

[ComVisible(true)]
public interface IAddInUtilities
{
    void ImportData();
}

[ComVisible(true)]
[ClassInterface(ClassInterfaceType.None)]
public class AddInUtilities : IAddInUtilities
{
    // This method tries to write a string to cell A1 in the active worksheet.
    public void ImportData()
    {
        Excel.Worksheet activeWorksheet = Globals.ThisAddIn.Application.ActiveSheet as Excel.Worksheet;

        if (activeWorksheet != null)
        {
            Excel.Range range1 = activeWorksheet.get_Range("A1", System.Type.Missing);
            range1.Value2 = "This is my data";
        }
    }
}

Expondo classes a VBA

Quando você executa as etapas fornecida acima, o código de VBA pode chamar apenas os métodos que você declarar a interface.O código de VBA não pode chamar quaisquer outros métodos na classe, incluindo os métodos que sua classe obtém as classes base como Object.

Você também pode expor a interface de IDispatch definindo o atributo de ClassInterfaceAttribute ao valor de AutoDispatch ou de AutoDual de enumeração de ClassInterfaceType .Se você fizer isso, você não precisa declarar os métodos em uma interface separadamente.Em o entanto, o código de VBA pode chamar os métodos públicos e não-estático em sua classe, incluindo os métodos obtidos das classes base como Object.Além de isso, os clientes fora de processo usando associação inicial não podem chamar sua classe.

Expondo classes para clientes fora de Processo

Se você deseja expor uma classe no suplemento para clientes fora de processo, você deve derivar da classe StandardOleMarshalObject para garantir que os clientes fora de processo podem chamar o objeto expõe do suplemento.Caso contrário, o tenta obter uma instância do objeto expõe em um cliente fora de processo podem falhar inesperadamente.

Isso ocorre porque todas as chamadas no modelo de objeto de um aplicativo do Office devem ser feitos no segmento principal de interface do usuário, mas chamadas de um cliente fora de processo para seu objeto chegarão em um segmento arbitrário de RPC (chamada de procedimento remoto).Empacotamento COM que o mecanismo no .NET Framework não alternará segmentos, e tentará vez para empacotar a chamada ao objeto no encadeamento de entrada de RPC em vez do segmento principal de interface do usuário.Se o objeto é uma instância de uma classe que deriva de StandardOleMarshalObject, chamadas de entrada ao objeto são automaticamente para o segmento onde o objeto expõe foi criado, que será o segmento principal de interface de usuário do aplicativo host.

Para obter mais informações sobre como usar segmento em soluções do Office, consulte Threading suporte no Office.

substituindo o método de RequestComAddInAutomationService

O exemplo de código a seguir demonstra como substituir RequestComAddInAutomationService na classe de ThisAddIn no suplemento.Este exemplo pressupõe que você definiu uma classe denominada AddInUtilities que você deseja expor a outras soluções.Para ver este código no contexto de um maior passo a passo, consulte Passo a passo: Chamando o código de um suplemento em nível de aplicativo do VBA.

Private utilities As AddInUtilities

Protected Overrides Function RequestComAddInAutomationService() As Object
    If utilities Is Nothing Then
        utilities = New AddInUtilities()
    End If
    Return utilities
End Function

private AddInUtilities utilities;

protected override object RequestComAddInAutomationService()
{
    if (utilities == null)
        utilities = new AddInUtilities();

    return utilities;
}

Quando o suplemento é carregado, Visual Studio Tools for Office Runtime chama o método de RequestComAddInAutomationService .O tempo de execução atribuir o objeto retornado para a propriedade de Object de um objeto de COMAddIn que representa o suplemento.Este objeto de COMAddIn está disponível para outras soluções do Office, e as soluções que automatizam o Office.

acessando objetos de outras soluções

Para chamar o objeto expõe no suplemento, execute as seguintes etapas na solução do cliente:

Obter o objeto de COMAddIn que representa o suplemento expostas.Os clientes podem acessar qualquer suplementos disponível usando a propriedade de Application.COMAddIns no modelo de objeto de aplicativo do Office host.
Acessar a propriedade de Object do objeto de COMAddIn .Essa propriedade retorna o objeto expõe do suplemento.
Chame os membros do objeto expõe.

A maneira que usa o valor de retorno da propriedade de COMAddIn.Object é diferente para clientes de VBA e de clientes não VBA.Para clientes fora de processo, o código adicional é necessário para evitar uma condição de corrida possível.

Acessando objetos de soluções de VBA

O exemplo de código demonstra como usar VBA para chamar um método que é exposto por um suplemento.Este chamadas macro de VBA um método chamado ImportData que é definido em um suplemento que é chamado ExcelImportData.Para ver este código no contexto de um maior passo a passo, consulte Passo a passo: Chamando o código de um suplemento em nível de aplicativo do VBA.

Sub CallVSTOMethod()
    Dim addIn As COMAddIn
    Dim automationObject As Object
    Set addIn = Application.COMAddIns("ExcelImportData")
    Set automationObject = addIn.Object
    automationObject.ImportData
End Sub

Acessando objetos de soluções de não VBA

Em uma solução de não VBA, você deve converter o valor da propriedade de COMAddIn.Object que implementa a interface e em seguida, você pode chamar métodos expostos no objeto da interface.O exemplo de código a seguir demonstra como chamar o método de ImportData de um suplemento diferente que foi criado usando as ferramentas do desenvolvedor do Office no Visual Studio.

Dim addIn As Office.COMAddIn = Globals.ThisAddIn.Application.COMAddIns.Item("ExcelImportData")
Dim utilities As ExcelImportData.IAddInUtilities = TryCast( _
    addIn.Object, ExcelImportData.IAddInUtilities)
utilities.ImportData()

object addInName = "ExcelImportData";
Office.COMAddIn addIn = Globals.ThisAddIn.Application.COMAddIns.Item(ref addInName);
ExcelImportData.IAddInUtilities utilities = (ExcelImportData.IAddInUtilities)addIn.Object;
utilities.ImportData();

Em esse exemplo, se você tentar converter o valor da propriedade de COMAddIn.Object a classe de AddInUtilities em vez da interface de IAddInUtilities , o código irá acionar InvalidCastException.

Consulte também

Partilhar via