Share via

Demonstra Passo a passo: Ativar compatibilidade com versões anteriores, sistema autônomo sistema autônomo alterações de host

  • Artigo

Esta explicação passo a passo descreve a versão 2 do pipeline é descrito em Demonstra Passo a passo: Criando um aplicativo extensível. Versão 2 inclui mais recursos de cálculo, fornecendo uma seqüência delimitada por vírgulas de operações aritméticas oferece suporte para o host.O host pode em seguida, escolher uma operação e enviar uma equação para o suplemento calcular.

O pipeline tem um novo host e um novo contrato.Para ativar a versão 1 do suplemento para trabalhar com um novo host e o contrato, o pipeline inclui o modo de exibição add-in usado para a versão 1 e um adaptador no lado do suplemento que converte os dados do modo de exibição de add-in mais antigo ao novo contrato.A ilustração a seguir mostra como os dois suplementos podem trabalhar com o mesmo host.

Novo host, add-ins antigos

Esse pipeline também está descrito na Suplemento cenários de pipeline.

Esta explicação passo a passo descreve as seguintes tarefas:

  • Criando uma solução do Visual Studio.

  • Criando a estrutura de diretório do pipeline.

  • Criação do contrato e modos de exibição.

  • Criando o adaptador no lado do suplemento, que inclui adaptadores para a nova versão do suplemento e para o add-in da versão 1.

  • Criando o adaptador do host.

  • Criando o host.

  • Criando o add-no.

  • Implantando o pipeline.

  • Executar o aplicativo host.

Explicação passo a passo também demonstra o uso de classes base abstratas para definir modos de exibição e mostra que esses modos de exibição são compatível com os modos de exibição que são definidos pelas interfaces.É recomendável usar interfaces.

Observação:

Alguns da c ODE Esta explicação passo a passo mostra contém referências a namespace irrelevantes.As etapas do passo-a-passo refletem com precisão as referências necessárias no Visual Studio.

Você pode encontrar código de exemplo adicionais e prévias de tecnologia do cliente de ferramentas para a criação de tubulações suplemento, com o Site de extensibilidade e suplemento estrutura gerenciado no CodePlex.

Pré-requisitos

Para completar este passo a passo, são necessários os seguintes componentes:

  • Visual Studio.

  • O pipeline de versão 1 descrito em Demonstra Passo a passo: Criando um aplicativo extensível. Como versão 2 usa pipeline de segmentos que foram desenvolvidos na versão 1, você deve desenvolver e implantar o pipeline de versão 1 antes de executar as etapas neste tópico.

Criando uma solução do Visual Studio

Usar uma solução em Visual Studio para conter projetos dos segmentos de pipeline.

Para criar a solução de pipeline

  1. In Visual Studio, crie um novo projeto chamado Calc2Contract.Basear o biblioteca de classes modelo.

  2. Nomeie a solução CalculatorV2.

Criando a estrutura de diretório de pipeline

O modelo de suplemento requer os assemblies de segmento pipeline a ser colocado em uma estrutura de diretórios especificada.

Para criar a estrutura de diretório de pipeline

  • Se você ainda não fez isso, adicione o CalcV2 pasta na estrutura da pasta pipeline que você criou no Demonstra Passo a passo: Criando um aplicativo extensível. The CalcV2 pasta manterá a nova versão do suplemento.

    Pipeline
  AddIns
    CalcV1
    CalcV2
  AddInSideAdapters
  AddInViews
  Contracts
  HostSideAdapters

    Não é necessário colocar a estrutura da pasta pipeline na sua pasta de aplicativo; ele é concluído apenas para conveniência nessas orientações.Se você colocar a estrutura de pastas de pipeline em um local diferente na primeiro explicação passo a passo, seguem o mesmo para esta explicação passo a passo.Consulte a discussão de requisitos pipeline diretório Requisitos de desenvolvimento de pipeline.

Criação do contrato e exibições

O segmento de contrato para esse pipeline define o ICalc2Contract interface, que tem dois métodos a seguir:

  • O método GetAvailableOperations.

    Esse método retorna uma seqüência de operações matemáticas que o suplemento ofereça suporte ao host.Versão 2 oferece suporte a cinco operações e esse método retorna a seqüência de caracteres"+,-,*,/,**"onde" ** "representa a Pow operação.

    Nos modos de exibição de suplemento e host, esse método é chamado Operations em vez de GetAvailableOperations.

    Você pode expor métodos no contrato sistema autônomo propriedades nos modos de exibição de convertendo a telefonar de método em uma propriedade no adaptador.

  • O método Operate.

    O host chama esse método para enviar uma equação para o suplemento calcular e retornar o resultado.

Para criar o contrato

  1. Na solução Visual Studio chamada CalculatorV2, em aberto the Calc2Contractprojeto .

  2. In O gerenciador de soluções, adicionar referências aos assemblies seguintes à Calc2Contract projeto:

    sistema.AddIn.contrato.dll

    sistema.AddIn.dll

  3. In O gerenciador de soluções, excluir a classe padrão que é adicionada à nova biblioteca de classes projetos.

  4. Adicionar um novo item ao projeto, usando o Interface modelo.No Adicionar novo item caixa de diálogo, a interface nomeICalc2Contract.

  5. No arquivo de interface adicionar referências do namespace a System.AddIn.Contract e System.AddIn.Pipeline.

  6. Use o código a seguir para concluir o segmento de contrato.Observe que esta interface deve ter o AddInContractAttribute atributo.

    Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic
Imports System.Text
Imports System.AddIn.Contract
Imports System.AddIn.Pipeline

Namespace CalculatorContracts
    <AddInContract()> _
    Public Interface ICalc2Contract
        Inherits IContract
        Function GetAvailableOperations() As String
        Function Operate(ByVal operation As String, ByVal a As Double, ByVal b As Double) As Double
    End Interface
End Namespace

    using System;
using System.Collections.Generic;
using System.Text;
using System.AddIn.Contract;
using System.AddIn.Pipeline;

namespace CalculatorContracts
{
    [AddInContract]
    public interface ICalc2Contract : IContract
    {      
        string GetAvailableOperations();
        double Operate(String operation, double a, double b);
    }
}

Como o modo de exibição de suplemento e o modo de exibição de host tem o mesmo código, você pode criar com com facilidade os modos de exibição ao mesmo time.Diferem em apenas um fator: o exibição de suplemento requer o AddInBaseAttribute atributo; a exibição do host do add - in faz não requer quaisquer atributos.

Para criar exibição de suplemento para versão 2

  1. Adicionar um novo projeto denominado Calc2AddInView to the CalculatorV2 solução.Basear o biblioteca de classes modelo.

  2. In O gerenciador de soluções, adicione uma referência ao sistema.AddIn.dll à Calc2AddInViewprojeto .

  3. Renomeie a classe Calculator2.

  4. No arquivo classe, adicione uma referência ao namespace para System.AddIn.Pipeline.

  5. Tornar Calculator2 an abstract (classeMustInherit classe no Visual Basic).

  6. Use o seguinte código para isso exibição de suplemento.Observe que essa classe deve ter o AddInBaseAttribute atributo.

    Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic
Imports System.Text
Imports System.AddIn.Pipeline

Namespace CalcAddInViews
    <AddInBase()> _
    Public MustInherit Class Calculator2
        Public MustOverride ReadOnly Property Operations() As String

        Public MustOverride Function Operate(ByVal operation As String, ByVal a As Double, ByVal b As Double) As Double
    End Class
End Namespace

    using System;
using System.Collections.Generic;
using System.Text;
using System.AddIn.Pipeline;

namespace CalcAddInViews
{
    [AddInBase]
    public abstract class Calculator2
    {
        public abstract string Operations
        {
            get;
        }

        public abstract double Operate(string operation, double a, double b);
    }
}

Para criar o modo de exibição do host a suplemento

  1. Adicionar um novo projeto denominado Calc2HVA to the CalculatorV2 solução.Basear o biblioteca de classes modelo.

  2. Renomeie a classe Calculadora.

  3. Tornar Calculadora an abstract (classeMustInherit classe no Visual Basic).

  4. No arquivo de classe, use o código a seguir para criar a exibição do host do suplemento.

    Imports Microsoft.VisualBasic
Imports System
Namespace CalcHVAs

    Public MustInherit Class Calculator

        Public MustOverride ReadOnly Property Operations() As String

        Public MustOverride Function Operate(ByVal operation As String, ByVal a As Double, ByVal b As Double) As Double
    End Class
End Namespace

    namespace CalcHVAs {


    public abstract class Calculator {

        public abstract string Operations
        {
            get;
        }

        public abstract double Operate(string operation, double a, double b);
    }
}

Para demonstrar o uso da versão 1 suplemento com o novo host, a solução deve incluir o modo de exibição de suplemento criado para a versão 1 do add-in de Calculadora.

Para adicionar o projeto de exibição suplemento da versão 1

  1. In O gerenciador de soluções, clicar com o botão direito do mouse o CalculatorV2 solução.

  2. clicar Adicionare, em seguida, clicar Projeto existente.

  3. Vá para as pastas que contêm o CalculatorV1 solução e selecionar o arquivo de projeto para o Calc1AddInViewprojeto .

Criando o adaptador no lado do suplemento

Isso adaptador no lado do suplemento consiste em dois adaptadores de tipo exibição-para-contrato: uma para adaptar-se a versão 2 exibição de suplemento para o contrato da versão 2 e uma para adaptar-se a versão 1 exibição de suplemento para o contrato da versão 2.

Nesse pipeline, o suplemento oferece um serviço para o host e os tipos de fluir do suplemento para o host.Porque não há tipos fluem do host para o suplemento, não é necessário incluir um adaptador de contrato para exibição.

Para criar o adaptador no lado do suplemento

  1. Adicionar um novo projeto denominado Calc2AddInSideAdapter to the CalculatorV2 solução.Basear o biblioteca de classes modelo.

  2. In O gerenciador de soluções, adicionar referências aos assemblies seguintes à Calc2AddInSideAdapter projeto:

    sistema.AddIn.dll

    sistema.AddIn.contrato.dll

  3. Adicione referências de projeto para os projetos a seguir:

    Calc2AddInView

    Calc2Contract

  4. selecionar cada referência de projeto e em Propriedades conjunto Copiar local to False, para impedir que os assemblies referenciados sejam copiadas para a pasta local de compilação.sistema autônomo assemblies estará localizados no diretório do pipeline, conforme descrito no procedimento "Implantando o pipeline", posteriormente nesta explicação passo a passo.No Visual Basic, utilize o Referências guia of Propriedades do projeto to conjunto Copiar local to False as referências de dois projeto.

  5. Renomear de classe do projeto padrão CalculatorViewToContractAddInSideAdapter.

  6. No arquivo classe, adicione uma referência ao namespace para System.AddIn.Pipeline.

  7. No arquivo classe, adicione referências a namespace para os segmentos adjacentes: CalcAddInViews and CalculatorContracts.(No Visual Basic, essas referências a namespace são Calc2AddInView.CalcAddInViews and Calc2Contract.CalculatorContracts, a menos que você tiver desativado os namespaces padrão em seus projetos do Visual Basic.)

  8. Use o seguinte código para esse adaptador adicionar no lado.O padrão de implementação é semelhante ao adaptador no lado do suplemento para a versão 1, embora a interface de contrato é muito diferente.

    Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic
Imports System.Text
Imports System.AddIn.Pipeline
Imports System.AddIn.Contract
Imports Calc2Contract.CalculatorContracts
Imports Calc2AddInView.CalcAddInViews

Namespace CalculatorContractsAddInAdapters

    <AddInAdapterAttribute()> _
    Public Class CalculatorViewToContractAddInAdapter
        Inherits ContractBase
        Implements ICalc2Contract

        Private _view As Calculator2

        Public Sub New(ByVal calculator As Calculator2)
            _view = calculator
        End Sub

        Public Function GetAvailableOperations() As String Implements ICalc2Contract.GetAvailableOperations
            Return _view.Operations
        End Function

        Public Function Operate(ByVal operation As String, ByVal a As Double, ByVal b As Double) As Double Implements ICalc2Contract.Operate
            Return _view.Operate(operation, a, b)
        End Function
    End Class
End Namespace

    using System.AddIn.Pipeline;
using CalcAddInViews;
using CalculatorContracts;


namespace CalcAddInSideAdapters {


    [AddInAdapterAttribute]
    public class CalculatorViewToContractAddInAdapter : ContractBase, ICalc2Contract {

        private Calculator2 _view;

        public CalculatorViewToContractAddInAdapter(Calculator2 calculator)
        {
            _view = calculator;
        }

        public string GetAvailableOperations()
        {
            return _view.Operations;
        }

        public double Operate(string operation, double a, double b)
        {
            return _view.Operate(operation, a, b);
        }

    }
}

Para ativar a versão 1 do suplemento para se comunicar com o novo host, pipeline para o add-in da versão 1 requer um adaptador no lado do suplemento que converte os dados do modo de exibição de suplemento antigo para o novo contrato.

Para criar a versão 1 ao adaptador no lado do suplemento da versão 2

  1. Adicionar um novo projeto denominado Calc2V1toV2AddInSideAdapter to the CalculatorV2 solução.Basear o biblioteca de classes modelo.

  2. In O gerenciador de soluções, adicionar referências aos assemblies seguintes à Calc2V1toV2AddInSideAdapter projeto:

    sistema.AddIn.dll

    sistema.AddIn.contrato.dll

  3. Adicione referências de projeto para os projetos a seguir:

    Calc1AddInView

    Calc2Contract

  4. selecionar cada referência de projeto e em Propriedades conjunto Copiar local to False, para impedir que os assemblies referenciados sejam copiadas para a pasta local de compilação.No Visual Basic, utilize o Referências guia of Propriedades do projeto to conjunto Copiar local to False as referências de dois projeto.

  5. Renomear de classe do projeto padrão Calc2V1ViewToV2ContractAddInSideAdapter.

  6. No arquivo classe, adicione uma referência ao namespace para System.AddIn.Pipeline.

  7. No arquivo classe, adicione referências a namespace para os segmentos adjacentes: CalcAddInViews and CalculatorContracts.(No Visual Basic essas referências a namespace são Calc1AddInView.CalcAddInViews and Calc2Contract.CalculatorContracts, a menos que você tiver desativado os namespaces padrão em seus projetos do Visual Basic.) Observe que o modo de exibição namespace é da versão 1 e o contrato é da versão 2.

  8. Aplicar o AddInAdapterAttribute atributo para o Calc2V1ViewToV2ContractAddInSideAdapter classe, para identificá-lo sistema autônomo o adaptador no lado do suplemento.

  9. Verifique o Calc2V1ViewToV2ContractAddInSideAdapter Herdar de classe de ContractBase, que fornece uma implementação padrão das IContract interface e implementar a interface de contrato versão 2 para o pipeline ICalc2Contract.

  10. Adicionar um construtor público que aceita um ICalculator, armazena em cache em um campo privado e chama o construtor da classe base.

  11. Para implementar os membros de ICalc2Contract, você deve telefonar os membros apropriados do ICalculator instância que é passada para o construtor e retornar os resultados.Devido as diferenças entre a versão 1 e versão 2 contrato interfaces, você deve ter um switch demonstrativo)Select Case demonstrativo no Visual Basic) para se adaptar o modo de exibição (ICalculator) o contrato (ICalc2Contract).

    O código a seguir mostra o adaptador adicionar no lado concluído.

    Imports System
Imports System.Collections.Generic
Imports System.Text
Imports System.AddIn.Pipeline
Imports Calc1AddInView.CalcAddInViews
Imports Calc2Contract.CalculatorContracts

Namespace AddInSideV1toV2Adapter


    <AddInAdapter()> _
    Public Class Calc2V1ViewToV2ContractAddInSideAdapter
        Inherits ContractBase
        Implements ICalc2Contract

        Private _view As ICalculator

        Public Sub New(ByVal calc As ICalculator)
            MyBase.New()
            _view = calc
        End Sub

        Public Function GetAvailableOperations() As String Implements ICalc2Contract.GetAvailableOperations
            Return "+, -, *, /"
        End Function

        Public Function Operate(ByVal operation As String, ByVal a As Double, ByVal b As Double) _
         As Double Implements ICalc2Contract.Operate
            Select Case (operation)
                Case "+"
                    Return _view.Add(a, b)
                Case "-"
                    Return _view.Subtract(a, b)
                Case "*"
                    Return _view.Multiply(a, b)
                Case "/"
                    Return _view.Divide(a, b)
                Case Else
                    Throw New InvalidOperationException(("This add-in does not support: " + operation))
            End Select
        End Function
    End Class
End Namespace

    using System;
using System.Collections.Generic;
using System.Text;
using System.AddIn.Pipeline;
using CalcAddInViews;
using CalculatorContracts;


namespace AddInSideV1toV2Adapter
{
    [AddInAdapter]
    public class Calc2V1ViewToV2ContractAddInSideAdapter : ContractBase, ICalc2Contract
    {
        ICalculator _view;

        public Calc2V1ViewToV2ContractAddInSideAdapter(ICalculator calc)
        {
            _view = calc;
        }

        public string GetAvailableOperations()
        {
            return  "+, -, *, /" ;
        }

        public double Operate(string operation, double a, double b)
        {
            switch (operation)
            {
                case "+":
                    return _view.Add(a, b);
                case "-":
                    return _view.Subtract(a, b);
                case "*":
                    return _view.Multiply(a, b);
                case "/":
                    return _view.Divide(a, b);
                default:
                    throw new InvalidOperationException("This add-in does not support: " + operation);
            }
        }

    }
}

Criando o adaptador no lado do host

Este adaptador do host é composto de um adaptador de contrato-para-exibição.Um adaptador de contrato para exibição é suficiente para oferecer suporte a ambas as versões do suplemento, porque cada adaptador no lado do suplemento converte de seu respectivo modo de exibição para o contrato da versão 2.

Esse pipeline, o suplemento fornece um serviço do host e o fluxo de tipos do add-in para o host.Porque não há tipos fluem do host para o suplemento, não é necessário incluir um adaptador do tipo exibição-para-contrato.

Para implementar o gerenciamento da vida útil, use um ContractHandle objeto para anexar um token de tempo de vida do contrato. Você deve manter uma referência a este identificador para que o gerenciamento da tempo de vida trabalhar.Depois que o token for aplicado, sem programação adicional é necessária porque o sistema suplemento pode descartar objetos quando eles não estão sendo usados e disponibilizá-los para a coleta de lixo.Para obter mais informações, consulte Gerenciamento de tempo de vida.

Para criar o adaptador do host

  1. Adicionar um novo projeto denominado Calc2HostSideAdapter to the CalculatorV2 solução.Basear o biblioteca de classes modelo.

  2. In O gerenciador de soluções, adicionar referências aos assemblies seguintes à Calc2HostSideAdapter projeto:

    sistema.AddIn.dll

    sistema.AddIn.contrato.dll

  3. Adicione referências de projeto para os projetos a seguir:

    Calc2Contract

    Calc2HVA

  4. selecionar cada referência de projeto e em Propriedades conjunto Copiar local to False, para impedir que os assemblies referenciados sejam copiadas para a pasta local de compilação.No Visual Basic, utilize o Referências guia of Propriedades do projeto to conjunto Copiar local to False as referências de dois projeto.

  5. Renomear de classe do projeto padrão CalculatorContractToViewHostSideAdapter.

  6. No arquivo classe, adicione referências a namespace para System.AddIn.Pipeline.

  7. No arquivo classe, adicione referências a namespace para os segmentos adjacentes: CalcHVAs and CalculatorContracts.(No Visual Basic, essas referências a namespace são Calc2HVA.CalcHVAs and Calc2Contract.CalculatorContracts, a menos que você tiver desativado os namespaces padrão em seus projetos do Visual Basic.)

  8. Aplicar o HostAdapterAttribute atributo para o CalculatorContractToViewHostSideAdapter classe, para identificá-lo sistema autônomo o adaptador do host.

  9. Verifique o CalculatorContractToViewHostSideAdapter classe herda a classe base abstrata que representa o modo de exibição do host a suplemento: CalcHVAs.calculadora (Calc2HVA.CalcHVAs.calculadora no Visual Basic).Observe a diferença da versão 1, onde o visão do complemento do host é uma interface.

  10. Adicionar um construtor público que aceita o tipo de contrato de pipeline, ICalc2Contract.O construtor deve armazenar em cache a referência ao contrato.Ele também deve criar e armazenar em cache um novo ContractHandle para o contrato para gerenciar o ciclo de vida do suplemento.

    Observação importante:

    O ContractHandle é fundamental para o gerenciamento da tempo de vida. Se você não conseguir manter uma referência à ContractHandle o objeto, coleta de lixo será solicitá-lo e a tubulação será desligado quando seu programa não espera. Isso pode levar a erros que são difíceis de diagnosticar como sistema autônomo AppDomainUnloadedException. desligado é um preparar da tempo de vida de um pipeline normal, portanto, não é possível para o código de gerenciamento de tempo de vida detectar essa condição é um erro.

  11. Quando você substituir os membros de Calculadora, basta chamar os membros correspondentes do ICalc2Contract instância que é passada para o construtor e retornar os resultados.Isso se adapta o contrato (ICalc2Contract) no modo de exibição (Calculadora).

    O código a seguir mostra o segmento concluído adaptador do host.

    Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic
Imports System.Text
Imports System.AddIn.Pipeline
Imports Calc2HVA.CalcHVAs
Imports Calc2Contract.CalculatorContracts

Namespace CalculatorContractsHostAdapers
    <HostAdapter()> _
    Public Class CalculatorContractToViewHostAdapter
        Inherits Calculator

    Private _contract As ICalc2Contract
    Private _handle As ContractHandle

    Public Sub New(ByVal contract As ICalc2Contract)
        _contract = contract
        _handle = New ContractHandle(contract)
    End Sub

    Public Overrides ReadOnly Property Operations() As String
        Get
            Return _contract.GetAvailableOperations()
        End Get
    End Property

    Public Overrides Function Operate(ByVal operation As String, ByVal a As Double, ByVal b As Double) As Double
        Return _contract.Operate(operation, a, b)
    End Function
End Class
End Namespace

    using System.AddIn.Pipeline;
using CalcHVAs;
using CalculatorContracts;

namespace CalcHostSideAdapters {


[HostAdapter]
public class CalculatorContractToViewHostAdapter : Calculator {

    private CalculatorContracts.ICalc2Contract _contract;

    private System.AddIn.Pipeline.ContractHandle _handle;

    public CalculatorContractToViewHostAdapter(ICalc2Contract contract) {
        _contract = contract;
        _handle = new System.AddIn.Pipeline.ContractHandle(contract);
    }


    public override string Operations
    {
        get 
        { 
            return _contract.GetAvailableOperations(); 
        }
    }

    public override double Operate(string operation, double a, double b)
    {
        return _contract.Operate(operation, a, b);
    }
 }
}

Criando o host

Um aplicativo host interage com o suplemento por meio do modo de exibição do host.Ele usa o suplemento detecção e ativação métodos fornecidos pelo AddInStore e AddInToken classes para fazer o seguinte:

  • Reconstrua o cache de informações de pipeline e o suplemento.

  • Localizar suplementos do tipo Calculator no diretório raiz do pipeline especificado.

  • Solicita que o usuário especifique quais suplemento usar.Neste exemplo, você verá dois suplementos disponível.

  • Ative o suplemento selecionado em um novo domínio do aplicativo com um nível de confiança de segurança especificado.

  • Executar o RunCalculator método chama métodos do suplemento conforme fornecido pela exibição do host do suplemento.

Para criar o host

  1. Adicionar um novo projeto denominado MathHost2 to the CalculatorV2 solução.Basear o Aplicativo de console modelo.

  2. In O gerenciador de soluções, adicione uma referência ao assembly sistema.AddIn.dll para o MathHost2projeto .

  3. Adicionar uma referência de projeto para o Calc2HVA projeto. selecionar a referência de projeto e em Propriedades conjunto Copiar local to False, para impedir que o assembly mencionado sejam copiadas para a pasta local de compilação.No Visual Basic, utilize o Referências guia of Propriedades do projeto to conjunto Copiar local to False.

  4. Renomeie a classe de arquivo (módulo no Visual Basic) MathHost2.

  5. No Visual Basic, utilize o Aplicativo Guia de do Propriedades do projeto caixa de diálogo conjuntoObjeto de inicialização to Sub Main.

  6. No arquivo de classe ou módulo, adicione uma referência ao namespace para System.AddIn.Hosting.

  7. No arquivo de classe ou módulo, adicione uma referência de espaço para nome para exibição do host do suplemento: CalcHVAs.(No Visual Basic, essa referência ao namespace é Calc2HVA.CalcHVAs, a menos que você tiver desativado os namespaces padrão em seus projetos do Visual Basic.)

  8. In O gerenciador de soluções, selecionar a solução e a partir de Projeto escolher de menu Propriedades.No Solução propriedade Pages caixa de diálogo, defina o Projeto de inicialização único para este projeto de aplicativo host.

  9. Use o código a seguir para criar o aplicativo host.

    Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic
Imports System.Collections.ObjectModel
Imports System.Text
Imports System.AddIn.Hosting
Imports Calc2HVA.CalcHVAs

Namespace Mathhost

    Module MathHost2

        Sub Main()
            ' Assume that the current directory is the application folder, 
            ' and that it contains the pipeline folder structure. 
            Dim pipeRoot As String = Environment.CurrentDirectory & "\Pipeline"

            ' Rebuild the cache of pipline and add-in information.
            AddInStore.Rebuild(pipeRoot)

            ' Find add-ins of type Calculator under the specified pipeline root directory.
            Dim tokens As Collection(Of AddInToken) = AddInStore.FindAddIns(GetType(Calculator), pipeRoot)

            ' Determine which add-in to use.
            Dim calcToken As AddInToken = ChooseCalculator(tokens)

            ' Activate the selected AddInToken in a new  
            ' application domain with a specified security trust level.
            Dim calculator As Calculator = calcToken.Activate(Of Calculator)(AddInSecurityLevel.Internet)

            ' Run the calculator.
            RunCalculator(calculator)
        End Sub

        Private Function ChooseCalculator(ByVal tokens As Collection(Of AddInToken)) As AddInToken
            If tokens.Count = 0 Then
                Console.WriteLine("No calculators are available")
                Return Nothing
            End If
            Console.WriteLine("Available Calculators: ")
            ' Show the token properties for each token 
            ' in the AddInToken collection (tokens),
            ' preceded by the add-in number in [] brackets.

            Dim tokNumber As Integer = 1
            For Each tok As AddInToken In tokens
                Console.WriteLine(vbTab & "[{0}]: {1} - {2}" & _
                        vbLf & vbTab & "{3}" & _
                        vbLf & vbTab & "{4}" & _
                        vbLf & vbTab & "{5} - {6}", _
                        tokNumber.ToString, tok.Name, _
                        tok.AddInFullName, tok.AssemblyName, _
                        tok.Description, tok.Version, tok.Publisher)
                tokNumber = tokNumber + 1
            Next
            Console.WriteLine("Which calculator do you want to use?")
            Dim line As String = Console.ReadLine()
            Dim selection As Integer
            If Int32.TryParse(line, selection) Then
                If selection <= tokens.Count Then
                    Return tokens(selection - 1)
                End If
            End If
            Console.WriteLine("Invalid selection: {0}. Please choose again.", line)
            Return ChooseCalculator(tokens)
        End Function

        Private Sub RunCalculator(ByVal calc As Calculator)

            If calc Is Nothing Then
                'No calculators were found, read a line and exit
                Console.ReadLine()
            End If
            Console.WriteLine("Available operations: " & calc.Operations)
            Console.WriteLine("Request a calculation , such as: 2 + 2")
            Console.WriteLine("Type ""exit"" to exit")
            Dim line As String = Console.ReadLine()
            Do While Not line.Equals("exit")
                ' Parser  
                Try
                    Dim c As Parser = New Parser(line)
                    Console.WriteLine(calc.Operate(c.action, c.A, c.B))
                Catch
                    Console.WriteLine("Invalid command: {0}. Commands must be formated: [number] [operation] [number]", line)
                    Console.WriteLine("Available operations: " & calc.Operations)
                End Try

                line = Console.ReadLine()
            Loop
        End Sub
    End Module


    Friend Class Parser

        Public partA As Double

        Public partB As Double

        Public action As String

        Friend Sub New(ByVal line As String)
            MyBase.New()
            Dim parts() As String = line.Split(" ")
            partA = Double.Parse(parts(0))
            action = parts(1)
            partB = Double.Parse(parts(2))
        End Sub

        Public ReadOnly Property A() As Double
            Get
                Return partA
            End Get
        End Property

        Public ReadOnly Property B() As Double
            Get
                Return partB
            End Get
        End Property

        Public ReadOnly Property CalcAction() As String
            Get
                Return action
            End Get
        End Property
    End Class
End Namespace

    using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Text;
using System.AddIn.Hosting;
using CalcHVAs;

namespace MathHost
{
    class Program
    {
        static void Main()
        {
            // Assume that the current directory is the application folder, 
            // and that it contains the pipeline folder structure. 
            String addInRoot = Environment.CurrentDirectory + "\\Pipeline";

            //Check to see if new add-ins have been installed.
            AddInStore.Rebuild(addInRoot);

            //Search for Calculator add-ins.
            Collection<AddInToken> tokens = AddInStore.FindAddIns(typeof(Calculator), addInRoot);

            //Ask the user which add-in they would like to use.
            AddInToken calcToken = ChooseCalculator(tokens);

            //Activate the selected AddInToken in a new
            //application domain with the Internet trust level.
            Calculator calculator = calcToken.Activate<Calculator>(AddInSecurityLevel.Internet);

            //Run the add-in.
            RunCalculator(calculator);
        }

        private static AddInToken ChooseCalculator(Collection<AddInToken> tokens)
        {
            if (tokens.Count == 0)
            {
                Console.WriteLine("No calculators are available");
                return null;
            }
            Console.WriteLine("Available Calculators: ");
            // Show the token properties for each token 
            // in the AddInToken collection (tokens),
            // preceded by the add-in number in [] brackets.
            int tokNumber = 1;
            foreach (AddInToken tok in tokens)
            {
                Console.WriteLine(String.Format("\t[{0}]: {1} - {2}\n\t{3}\n\t\t {4}\n\t\t {5} - {6}",
                    tokNumber.ToString(), 
                    tok.Name,
                    tok.AddInFullName,
                    tok.AssemblyName,
                    tok.Description,
                    tok.Version,
                    tok.Publisher));
                tokNumber++;
            }
            Console.WriteLine("Which calculator do you want to use?");
            String line = Console.ReadLine();
            int selection;
            if (Int32.TryParse(line, out selection))
            {
                if (selection <= tokens.Count)
                {
                    return tokens[selection - 1];
                }
            }
            Console.WriteLine("Invalid selection: {0}. Please choose again.", line);
            return ChooseCalculator(tokens);
        }

        private static void RunCalculator(Calculator calc)
        {

            if (calc == null)
            {
                //No calculators were found, read a line and exit.
                Console.ReadLine();
            }
            Console.WriteLine("Available operations: " + calc.Operations);
            Console.WriteLine("Type \"exit\" to exit");
            String line = Console.ReadLine();
            while (!line.Equals("exit"))
            {
                // The Parser class parses the user's input.
                try
                {
                    Parser c = new Parser(line);
                    Console.WriteLine(calc.Operate(c.Action, c.A, c.B));
                }
                catch
                {
                    Console.WriteLine("Invalid command: {0}. Commands must be formated: [number] [operation] [number]", line);
                    Console.WriteLine("Available operations: " + calc.Operations);
                }

                line = Console.ReadLine();
            }
        }
    }


    internal class Parser
    {
        internal Parser(String line)
        {
            String[] parts = line.Trim().Split(' ');
            a = Double.Parse(parts[0]);
            action = parts[1];
            b = Double.Parse(parts[2]);
        }

        double a;

        public double A
        {
            get { return a; }
        }
        double b;

        public double B
        {
            get { return b; }
        }
        String action;

        public String Action
        {
            get { return action; }
        }
    }
}
    Observação:

    Esse código supõe que a estrutura da pasta pipeline encontra-se em pasta do aplicativo.Se localizado-lo em outro local, altere a linha de código que define o addInRoot variável para que a variável contém o caminho para sua estrutura de diretório do pipeline.

Criando o suplemento

Um suplemento implementa os métodos especificados pelo exibição de suplemento.Neste suplemento, o Operations método retorna uma seqüência de caracteres que lista as operações matemáticas que o suplemento ofereça suporte. The Operate método fornece o código para calcular o resultado com base na seleção do host de uma operação e dois números.

Para criar o suplemento

  1. Adicionar um novo projeto denominado AddInCalcV2 to the CalculatorV2 solução.Basear o biblioteca de classes modelo.

  2. In O gerenciador de soluções, adicionar referências aos assemblies seguintes à AddInCalcV2 projeto:

    sistema.AddIn.dll

    sistema.AddIn.contrato.dll

  3. Adicionar uma referência de projeto para o Calc2AddInView projeto. selecionar a referência de projeto e em Propriedades conjunto Copiar local to False, para impedir que o assembly mencionado sejam copiadas para a pasta local de compilação.No Visual Basic, utilize o Referências guia of Propriedades do projeto to conjunto Copiar local to False.

  4. Renomeie o arquivo de classe SampleV2AddIn.

  5. No arquivo classe, adicione referências a namespace para System.AddIn e System.AddIn.Pipeline. System.AddIn.Pipeline é necessário apenas porque o código inclui um exemplo da QualificationDataAttribute atributo.

  6. No arquivo classe, adicione uma referência ao namespace para o segmento de exibição de suplemento 2 versão: CalcAddInViews (Calc2AddInView.CalcAddInViews no Visual Basic).

  7. Aplicar o AddInAttribute atributo para o SampleV2AddIn classe, para identificar a classe sistema autônomo um suplemento.

  8. Aplicar o QualificationDataAttribute atributo para o SampleV2AddIn classe e especifique as informações que o host pode recuperar das AddInToken. Nesse caso, as informações sugerem que o suplemento deve ser carregado em seu próprio domínio do aplicativo.Consulte Como: Usar dados de qualificação.

  9. Verifique o SampleV2AddIn classe herda a classe base abstrata que representa o modo de exibição do suplemento: Calculator2.

  10. Substituir os membros de Calculator2 e retornar os resultados dos cálculos apropriados.

    O código a seguir mostra o suplemento concluído.

    Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic
Imports System.Text
Imports System.AddIn
Imports System.AddIn.Pipeline
Imports Calc2AddInView.CalcAddInViews

Namespace CalculatorAddIns
' This pipeline segment has
' two attributes:
' 1 - An AddInAttribute to identify
'     this segment as an add-in.
'
' 2 - A QualificationDataAttribute to
'     indicate that the add-in should
'     be loaded into a new application domain.

<AddIn("Calculator Add-in", Version:="2.0.0.0")> _
<QualificationData("Isolation", "NewAppDomain")> _
    Public Class SampleV2AddIn
    Inherits Calculator2
Public Overrides ReadOnly Property Operations() As String
    Get
        Return "+, -, *, /, **"
    End Get
End Property

Public Overrides Function Operate(ByVal operation As String, _
        ByVal a As Double, ByVal b As Double) As Double
    Select Case operation
        Case "+"
            Return a + b
        Case "-"
            Return a - b
        Case "*"
            Return a * b
        Case "/"
            Return a / b
        Case "**"
            Return Math.Pow(a, b)
        Case Else
            Throw New InvalidOperationException("This add-in does not support: " & operation)
    End Select
End Function

End Class
End Namespace

    using System;
using System.Collections.Generic;
using System.Text;
using System.AddIn;
using System.AddIn.Pipeline;
using CalcAddInViews;
namespace CalcAddIns
{
// This pipeline segment has
// two attributes:
// 1 - An AddInAttribute to identify
//     this segment as an add-in.
//
// 2 - A QualificationDataAttribute to
//     indicate that the add-in should
//     be loaded into a new application domain.

    [AddIn("Calculator Add-in",Version="2.0.0.0")]
    [QualificationData("Isolation", "NewAppDomain")]
    public class SampleV2AddIn : Calculator2
    {
        public override string Operations
        {
            get
            {
                return "+, -, *, /, **";
            }
        }

        public override double Operate(string operation, double a, double b)
        {
            switch (operation)
            {
                case "+":
                    return a + b;
                case "-":
                    return a - b;
                case "*":
                    return a * b;
                case "/":
                    return a / b;
                case "**":
                    return Math.Pow(a, b);
                default:
                    throw new InvalidOperationException("This add-in does not support: " + operation);
            }
        }

    }
}

Implantando o pipeline

Agora você está pronto para compilação e implantar os segmentos do suplemento para a estrutura de diretório do pipeline necessários.

Para distribuir os segmentos para o pipeline

  1. Para cada projeto na solução, use o Compilação tab of Propriedades do projeto (the Compilar guia no Visual Basic) para conjunto o valor do Caminho de saída (the Construir o caminho de saída no Visual Basic).Se você nomeou seu aplicativo de pasta MyApp, por exemplo, seus projetos seriam compilação nas seguintes pastas:

    Project

    Caminho

    AddInCalcV2

    MyApp\Pipeline\AddIns\CalcV2

    Calc2AddInSideAdapter

    MyApp\Pipeline\AddInSideAdapters

    Calc2V1toV2AddInSideAdapter

    MyApp\Pipeline\AddInSideAdapters

    Calc1AddInView

    MyApp\Pipeline\AddInViews

    Calc2AddInView

    MyApp\Pipeline\AddInViews

    Calc2Contract

    MyApp\Pipeline\Contracts

    MathHost2

    MyApp

    Calc2HostSideAdapter

    MyApp\Pipeline\HostSideAdapters

    Calc2HVA

    MyApp
    Observação:

    Se você colocar seu estrutura de pastas de pipeline no um local diferente sua pasta de aplicativo , você deve modificar os caminhos mostrados na tabela adequadamente .

  2. Crie a solução do Visual Studio.

  3. Verifique os diretórios de aplicativo e de pipeline, para garantir que os assemblies foram copiados para os diretórios corretos e que não há cópias extras dos assemblies foram instaladas nas pastas erradas.

    Observação:

    I -F- não foi alterado Copiar local to False for the Calc2AddInView referência de projeto na AddInCalcV2 projeto, carregador contexto problemas impedirá o suplemento estando localizados.

    Para obter informações sobre a implantação no pipeline, consulte Requisitos de desenvolvimento de pipeline.

Executando o aplicativo host

Agora você está pronto para executar o host e interagir com os suplementos.

Para executar aplicativo host

  1. Certifique-se de que as duas versões do suplemento são implantados.

  2. No aviso de comando, vá para o diretório de aplicativo e execute o aplicativo host.Neste exemplo, o aplicativo host é MathHost2.exe.

  3. Ele localiza todos os suplementos disponível do seu tipo e solicita que você selecionar um suplemento.Digite 1 ou 2.

  4. Digite uma equação para a Calculadora, por exemplo, 2 + 2.

  5. Digite sair e pressione o Digite tecla para fechar o aplicativo.

  6. Repetir as etapas 2 a 5 para executar o Outros suplemento.

Consulte também

Tarefas

Demonstra Passo a passo: Criando um aplicativo extensível

Demonstra Passo a passo: Coleções de passagem entre hosts e suplementos

Conceitos

Requisitos de desenvolvimento de pipeline

Contratos, exibições e adaptadores

Desenvolvimento de pipeline

Date

History

Motivo

Julho de 2008

Fixos erros no texto.Adicionar uma observação sobre como manter uma referência ao contrato.

Comentários do cliente.