Demonstra Passo a passo: Ativando a compatibilidade com versões anteriores, como as alterações de Host

Artigo
08/01/2011

Esta explicação passo a passo descreve a versão 2 do pipeline descrita no Demonstra Passo a passo: Criando um aplicativo extensível. Versão 2 inclui mais recursos de cálculo, fornecendo uma seqüência de caracteres delimitada por ponto-e-vírgula de operações aritméticas, ele oferece suporte para o host. O host pode 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 a exibição de add-in usada para a versão 1 e um adaptador de adicionar no lado que converte os dados no modo de exibição de adicionar mais antiga para o novo contrato. A ilustração a seguir mostra como os dois suplementos podem trabalhar com o mesmo host.

Novo host, add-ins antigos

Cenário do pipeline: host novo, suplementos antigos.

Esse pipeline também está descrito na Cenários do Pipeline de suplemento.

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

Criando uma solução de Visual Studio.
Criando a estrutura do diretório de pipeline.
Criando o contrato e os modos de exibição.
Criando o adaptador de adicionar no lado, o que inclui os adaptadores para a nova versão do suplemento e o add-in da versão 1.
Criando o adaptador de host.
Criando o host.
Criando o suplemento.
Implantando o pipeline.
Executando 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íveis com os modos de exibição são definidos pelas interfaces. É recomendável usar interfaces.

Observação

Parte do código mostrado nesta explicação contém referências a namespace irrelevantes.As etapas de explicação passo a passo refletem com precisão as referências necessárias em Visual Studio.

Você pode encontrar o código de exemplo adicionais e customer technology previews das ferramentas para construção suplemento tubulações, na site extensibilidade gerenciada e a estrutura de suplemento 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 os segmentos de pipeline que foram desenvolvidos na versão 1, deve desenvolver e implantar o pipeline de versão 1 antes de executar as etapas neste tópico.

Criação de uma solução de Visual Studio

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

Para criar a solução de pipeline

Em Visual Studio, crie um novo projeto chamado Calc2Contract. Baseá-lo na Biblioteca de classe modelo.
Nomeie a solução CalculatorV2.

Criando a estrutura do diretório de Pipeline

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

Para criar a estrutura do diretório de pipeline

Se você não tiver feito isso, adicione a CalcV2 a estrutura de pastas de pipeline que você criou na pasta Demonstra Passo a passo: Criando um aplicativo extensível. O CalcV2 pasta manterá a nova versão do add-in.
```
Pipeline
  AddIns
    CalcV1
    CalcV2
  AddInSideAdapters
  AddInViews
  Contracts
  HostSideAdapters
```
Não é necessário colocar a estrutura de pastas do pipeline na sua pasta de aplicativo; ele é feito apenas por conveniência nessas orientações. Se você colocar a estrutura de pastas de pipeline em um local diferente na primeira explicação, siga o mesmo padrão para esta explicação passo a passo. Consulte a discussão de requisitos do diretório de pipeline em Requisitos de desenvolvimento de pipeline.

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

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 oferece suporte para o host. Versão 2 oferece suporte a operações de cinco, e esse método retorna a seqüência "+,-,*,/,**" onde "**" representa o Pow operação.

Nas exibições de add-in e o host, esse método é chamado Operations em vez de GetAvailableOperations.

Você pode expor métodos no contrato como propriedades em modos de exibição através da conversão de chamada 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.

Na solução de Visual Studio chamada CalculatorV2, abra o Calc2Contract project.
Em Solution Explorer, adicionar referências aos seguintes assemblies para o Calc2Contract projeto:

System.addin.Contract.dll

System.addin.dll
Em Solution Explorer, excluir a classe padrão que é adicionada à nova Biblioteca de classe projetos.
Adicionar um novo item ao projeto, usando o Interface modelo. No Add New Item caixa de diálogo, o nome da interface ICalc2Contract.
O arquivo de interface Adicionar referências a namespace para System.AddIn.Contract e System.AddIn.Pipeline.

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

Porque o modo de exibição do suplemento e o modo de exibição de host tem o mesmo código, você pode criar facilmente os modos de exibição ao mesmo tempo. Diferem apenas um fator: o modo de exibição do suplemento requer o AddInBaseAttribute atributo; o modo de exibição de host do add-in não requer quaisquer atributos.

Para criar a exibição do suplemento para a versão 2

Adicionar um novo projeto chamado Calc2AddInView para o CalculatorV2 solução. Baseá-lo na Biblioteca de classe modelo.
Em Solution Explorer, adicione uma referência a System.AddIn.dll para o Calc2AddInView project.
Renomeie a classe Calculator2.
No arquivo de classe, adicione uma referência ao namespace para System.AddIn.Pipeline.
Verifique Calculator2 um abstract classe (MustInherit classe Visual Basic).

Use o seguinte código para este modo de exibição do 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 a exibição de host do add-in

Adicionar um novo projeto chamado Calc2HVA para o CalculatorV2 solução. Baseá-lo na Biblioteca de classe modelo.
Renomeie a classe Calculadora.
Verifique Calculadora um abstract classe (MustInherit classe Visual Basic).

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

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 a exibição de suplemento criada para a versão 1 do add-in de Calculadora.

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

Em Solution Explorer, com o botão direito do CalculatorV2 solução.
Clique em Adde em seguida, clique em Projeto existente.
Vá para as pastas que contêm o CalculatorV1 arquivo de solução e selecione o projeto para o Calc1AddInView project.

Criação do adaptador de adicionar no lado

Este adaptador de adicionar no lado consiste em dois adaptadores de modo de exibição-para-contrato: uma para adaptar-se a versão 2 suplemento exibição para o contrato da versão 2 e outra para adaptar-se a versão 1 add-in visualização para o contrato da versão 2.

Nesse pipeline, o suplemento oferece um serviço para o host e os tipos de fluxo do add-in para o host. Porque nenhum tipo de fluxo do host para o suplemento, não possuem incluem um adaptador de exibição de contrato.

Para criar o adaptador de adicionar no lado

Adicionar um novo projeto chamado Calc2AddInSideAdapter para o CalculatorV2 solução. Baseá-lo na Biblioteca de classe modelo.
Em Solution Explorer, adicionar referências aos seguintes assemblies para o Calc2AddInSideAdapter projeto:

System.addin.dll

System.addin.Contract.dll
Adicione referências de projeto para os seguintes projetos:

Calc2AddInView

Calc2Contract
Selecione cada referência de projeto e em Propriedades definir Copy Local para False, para impedir que os assemblies referenciados sejam copiadas para a pasta build do local. Os assemblies estará localizados no diretório de pipeline, conforme descrito em "Implantando o Pipeline" procedimento posteriormente nesta explicação passo a passo. No Visual Basic, use o referências guia de Propriedades do projeto para definir Copy Local para False para as duas referências de projeto.
Renomeie a classe do projeto padrão CalculatorViewToContractAddInSideAdapter.
No arquivo de classe, adicione uma referência ao namespace para System.AddIn.Pipeline.
No arquivo de classe, adicione referências a namespace para os segmentos adjacentes: CalcAddInViews e CalculatorContracts. (Visual Basic, essas referências do namespace são Calc2AddInView.CalcAddInViews e Calc2Contract.CalculatorContracts, a menos que você tenha desativado os namespaces padrão em seus projetos de Visual Basic.)

Use o seguinte código para esse adaptador de adicionar no lado. O padrão de implementação é semelhante para o adaptador de adicionar no lado da 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, o pipeline para o add-in da versão 1 requer um adaptador de adicionar no lado que converte os dados do modo de exibição de suplemento antigo para o novo contrato.

Para criar a versão 1 para o adaptador de adicionar no lado da versão 2

Adicionar um novo projeto chamado Calc2V1toV2AddInSideAdapter para o CalculatorV2 solução. Baseá-lo na Biblioteca de classe modelo.
Em Solution Explorer, adicionar referências aos seguintes assemblies para o Calc2V1toV2AddInSideAdapter projeto:

System.addin.dll

System.addin.Contract.dll
Adicione referências de projeto para os seguintes projetos:

Calc1AddInView

Calc2Contract
Selecione cada referência de projeto e em Propriedades definir Copy Local para False, para impedir que os assemblies referenciados sejam copiadas para a pasta build do local. No Visual Basic, use o referências guia de Propriedades do projeto para definir Copy Local para False para as duas referências de projeto.
Renomeie a classe do projeto padrão Calc2V1ViewToV2ContractAddInSideAdapter.
No arquivo de classe, adicione uma referência ao namespace para System.AddIn.Pipeline.
No arquivo de classe, adicione referências a namespace para os segmentos adjacentes: CalcAddInViews e CalculatorContracts. (Visual Basic essas referências do namespace são Calc1AddInView.CalcAddInViews e Calc2Contract.CalculatorContracts, a menos que você tenha desativado os namespaces padrão em seus projetos de Visual Basic.) Observe que o namespace do modo de exibição é da versão 1 e o contrato é da versão 2.
Aplicar o AddInAdapterAttribute de atributo para o Calc2V1ViewToV2ContractAddInSideAdapter classe, para identificá-lo como o adaptador de adicionar no lado.
Verifique o Calc2V1ViewToV2ContractAddInSideAdapter herdam da classe ContractBase, que fornece uma implementação padrão da IContract interface e implementar a interface de contrato 2 da versão para o pipeline, ICalc2Contract.
Adicionar um construtor público que aceita um ICalculator, armazena em cache em um campo particular e chama o construtor da classe base.

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

O código a seguir mostra o adaptador de 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 de Host

Este adaptador de host consiste em um adaptador de exibição de contrato. Um adaptador de exibição de contrato é suficiente para suportar as duas versões do suplemento, porque cada adaptador de adicionar no lado converte de seu respectivo modo de exibição para o contrato da versão 2.

Nesse pipeline, o suplemento oferece um serviço do host e o fluxo de tipos do add-in para o host. Porque nenhum tipo de fluxo do host para o suplemento, não possuem incluem um adaptador de exibição para o contrato.

Para implementar o gerenciamento da vida útil, use um ContractHandle o 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 vida útil trabalhar. Depois que o token é aplicado, nenhuma programação adicional é necessária porque o sistema de add-in pode descartar objetos quando eles não estão sendo usados e disponibilização-los para coleta de lixo. Para obter mais informações, consulte Gerenciamento da vida útil.

Para criar o adaptador de host

Adicionar um novo projeto chamado Calc2HostSideAdapter para o CalculatorV2 solução. Baseá-lo na Biblioteca de classe modelo.
Em Solution Explorer, adicionar referências aos seguintes assemblies para o Calc2HostSideAdapter projeto:

System.addin.dll

System.addin.Contract.dll
Adicione referências de projeto para os seguintes projetos:

Calc2Contract

Calc2HVA
Selecione cada referência de projeto e em Propriedades definir Copy Local para False, para impedir que os assemblies referenciados sejam copiadas para a pasta build do local. No Visual Basic, use o referências guia de Propriedades do projeto para definir Copy Local para False para as duas referências de projeto.
Renomeie a classe do projeto padrão CalculatorContractToViewHostSideAdapter.
No arquivo de classe, adicione referências a namespace para System.AddIn.Pipeline.
No arquivo de classe, adicione referências a namespace para os segmentos adjacentes: CalcHVAs e CalculatorContracts. (Visual Basic, essas referências do namespace são Calc2HVA.CalcHVAs e Calc2Contract.CalculatorContracts, a menos que você tenha desativado os namespaces padrão em seus projetos de Visual Basic.)
Aplicar o HostAdapterAttribute de atributo para o CalculatorContractToViewHostSideAdapter classe, para identificá-lo como o adaptador de host.
Verifique o CalculatorContractToViewHostSideAdapter classe herda a classe base abstrata que representa o modo de exibição de host do add-in: CalcHVAs.Calculator (Calc2HVA.CalcHVAs.Calculator em Visual Basic). Observe a diferença da versão 1, onde o modo de exibição de host do add-in é uma interface.
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 uma nova ContractHandle para o contrato, para gerenciar a vida útil do add-in.

Observação

O ContractHandle é fundamental para o gerenciamento do ciclo de vida.Se você deixar de manter uma referência para o ContractHandle , coleta de lixo será solicitá-lo, e objeto pipeline será desligado quando o seu programa não espera o proprietário.Isso pode levar a erros que são difíceis de diagnosticar, como AppDomainUnloadedException.Desligamento é um estágio normal na vida de um pipeline, portanto não há nenhuma maneira para o código de gerenciamento da vida útil detectar que essa condição é um erro.

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

O código a seguir mostra o segmento de adaptador concluído do lado 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);
    }
 }
}

Criação do Host

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

Reconstrua o cache das informações de pipeline e o suplemento.
Localizar suplementos do tipo Calculator sob o diretório de raiz do pipeline especificado.
Solicite ao usuário especificar qual suplemento para usar. Neste exemplo, você verá dois suplementos disponíveis.
Ative o suplemento selecionado em um novo domínio de aplicativo com um nível de confiança de segurança especificado.
Execute o RunCalculator método, que chama os métodos do suplemento conforme fornecido pela exibição do host do add-in.

Para criar o host

Adicionar um novo projeto chamado MathHost2 para o CalculatorV2 solução. Baseá-lo sobre o O aplicativo de Console modelo.
Em Solution Explorer, adicione uma referência ao assembly System.AddIn.dll para o MathHost2 project.
Adicione uma referência para o Calc2HVA project. Selecione a referência de projeto e em Propriedades definir Copy Local para False, para impedir que o assembly referenciado sejam copiadas para a pasta build do local. No Visual Basic, use o referências guia de Propriedades do projeto para definir Copy Local para False.
Renomeie o arquivo de classe (módulo de Visual Basic) MathHost2.
No Visual Basic, use o aplicativo guia da Propriedades do projeto caixa de diálogo para definir o objeto de inicialização para Sub Main.
No arquivo de classe ou módulo, adicione uma referência ao namespace para System.AddIn.Hosting.
No arquivo de classe ou módulo, adicione uma referência ao namespace para a exibição do host do add-in: CalcHVAs. (Visual Basic, essa referência ao namespace é Calc2HVA.CalcHVAs, a menos que você tenha desativado os namespaces padrão em seus projetos de Visual Basic.)
Em Solution Explorer, selecione a solução e o projeto menu escolha Propriedades. No Solution Property Pages caixa de diálogo, definir o Único projeto de inicialização ser este projeto de aplicativo do host.

Use o seguinte código 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 pressupõe que a estrutura de pastas de pipeline está localizada na pasta do aplicativo.Se você localizado-lo em outro lugar, altere a linha de código que define o addInRoot variável para que a variável contém o caminho para a sua estrutura de diretório de pipeline.

Criando o suplemento

Um suplemento implementa os métodos especificados pelo modo de exibição do suplemento. Este add-in, o Operations método retorna uma seqüência que lista as operações matemáticas que o suplemento oferece suporte. O 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

Adicionar um novo projeto chamado AddInCalcV2 para o CalculatorV2 solução. Baseá-lo na Biblioteca de classe modelo.
Em Solution Explorer, adicionar referências aos seguintes assemblies para o AddInCalcV2 projeto:

System.addin.dll

System.addin.Contract.dll
Adicione uma referência para o Calc2AddInView project. Selecione a referência de projeto e em Propriedades definir Copy Local para False, para impedir que o assembly referenciado sejam copiadas para a pasta build do local. No Visual Basic, use o referências guia de Propriedades do projeto para definir Copy Local para False.
Renomeie o arquivo de classe SampleV2AddIn.
No arquivo de 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.
No arquivo de classe, adicione uma referência ao namespace para o segmento de exibição de suplemento 2 versão: CalcAddInViews (Calc2AddInView.CalcAddInViews em Visual Basic).
Aplicar o AddInAttribute de atributo para o SampleV2AddIn classe, para identificar a classe como um add-in.
Aplicar o QualificationDataAttribute atributo para o SampleV2AddIn classe e especifique as informações que o host pode recuperar a partir do AddInToken. Nesse caso, as informações sugerem que o suplemento deve ser carregado em seu próprio domínio de aplicativo. Consulte Como: Usar dados de qualificação.
Verifique o SampleV2AddIn classe herda a classe base abstrata que representa o modo de exibição do suplemento: Calculator2.

Substituir os membros do 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 criar e implantar os segmentos de adicionar a estrutura do diretório de pipeline necessários.

Para implantar os segmentos de pipeline

Para cada projeto na solução, use o Build guia de Propriedades do projeto (o compilar guia Visual Basic) para definir o valor da caminho de saída (o Build output path em Visual Basic). Se você nomeou a sua pasta de aplicativo MyApp, por exemplo, seus projetos criaria 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 a estrutura de pastas de pipeline em um local diferente da pasta do seu aplicativo, você deve modificar os caminhos mostrados na tabela de acordo.

Crie a solução de Visual Studio.
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

Se você não alterou Copy Local para False para o Calc2AddInView referência de projeto de AddInCalcV2 projeto, problemas de contexto do carregador impedirá o add-in que está sendo localizado.

Para obter informações sobre como implantar o 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 o aplicativo host

Certifique-se de que as duas versões do suplemento são implantados.
No prompt de comando, vá para o diretório de aplicativo e executar o aplicativo host. Neste exemplo, o aplicativo host é MathHost2.exe.
O host localiza todos os suplementos disponíveis do seu tipo e solicita que você selecione um add-in. Digite 1 ou 2.
Insira uma equação para a Calculadora, como, por exemplo, 2 + 2.
Digite exit e pressione o Enter chave para fechar o aplicativo.
Repita as etapas de 2 a 5 para executar o outro 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

Compartilhar via

Demonstra Passo a passo: Ativando a compatibilidade com versões anteriores, como as alterações de Host

Pré-requisitos

Criação de uma solução de Visual Studio

Para criar a solução de pipeline

Criando a estrutura do diretório de Pipeline

Para criar a estrutura do diretório de pipeline

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

Para criar o contrato.

Para criar a exibição do suplemento para a versão 2

Para criar a exibição de host do add-in

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

Criação do adaptador de adicionar no lado

Para criar o adaptador de adicionar no lado

Para criar a versão 1 para o adaptador de adicionar no lado da versão 2

Criando o adaptador de Host

Para criar o adaptador de host

Criação do Host

Para criar o host

Criando o suplemento

Para criar o suplemento

Implantando o Pipeline

Para implantar os segmentos de pipeline

Executando o aplicativo Host

Para executar o aplicativo host

Consulte também

Tarefas

Conceitos

Recursos adicionais