Demonstra Passo a passo: Criando um aplicativo extensível

Artigo
08/01/2011

Esta explicação passo a passo descreve como criar um pipeline para um suplemento que executa funções da Calculadora simples. Não demonstre um cenário do mundo real; em vez disso, ele demonstra a funcionalidade básica de um pipeline e como um suplemento pode fornecer serviços para um host.

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 lado em Adicionar.
Criando o adaptador de host.
Criando o host.
Criando o suplemento.
Implantando o pipeline.
Executando o aplicativo host.

Esse pipeline passa apenas os tipos serializáveis (Double e String), entre o host e o add-in. Para obter um exemplo que mostra como passar coleções de tipos de dados complexos, consulte Demonstra Passo a passo: Coleções de passagem entre Hosts e suplementos.

O contrato para esse pipeline define um modelo de objeto de quatro operações aritméticas: Adicionar, subtrair, multiplicar e dividir. O host fornece o add-in com uma equação para calcular, como, por exemplo, 2 + 2 e o suplemento retorna o resultado para o host.

A versão 2 do suplemento Calculadora fornece as possibilidades de cálculo mais e demonstra o controle de versão. Ele está descrito no Demonstra Passo a passo: Ativando a compatibilidade com versões anteriores, como as alterações de Host.

Observação

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

Você precisa fazer o seguinte para concluir este passo a passo:

Visual Studio.

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 Calc1Contract. Baseá-lo na Biblioteca de classe modelo.
Nomeie a solução CalculatorV1.

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 obter mais informações sobre a estrutura do pipeline, consulte Requisitos de desenvolvimento de pipeline.

Para criar a estrutura do diretório de pipeline

Crie uma pasta de aplicativo em qualquer lugar no seu computador.
Nessa pasta, crie a seguinte estrutura:
```
Pipeline
  AddIns
    CalcV1
    CalcV2
  AddInSideAdapters
  AddInViews
  Contracts
  HostSideAdapters
```
Não é necessário colocar a estrutura de pastas do pipeline na sua pasta de aplicativo; é feito aqui apenas para sua conveniência. Na etapa de apropriado, a explicação passo a passo explica como alterar o código, se a estrutura de pastas de pipeline está em um local diferente. Consulte a discussão de requisitos do diretório de pipeline em Requisitos de desenvolvimento de pipeline.

Observação

O CalcV2 pasta não é usada nesta explicação passo a passo; é um espaço reservado para Demonstra Passo a passo: Ativando a compatibilidade com versões anteriores, como as alterações de Host.

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

O segmento de contrato para esse pipeline define o ICalc1Contract interface, que define quatro métodos: add, subtract, multiply, and divide.

Para criar o contrato.

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

System.addin.Contract.dll

System.addin.dll
Em Solution Explorer, excluir a classe padrão que é adicionada à nova Biblioteca de classe projetos.
Em Solution Explorer, adicione um novo item ao projeto, usando o Interface modelo. No Add New Item caixa de diálogo, o nome da interface ICalc1Contract.
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 esse segmento do contrato. Observe que esta interface deve ter o AddInContractAttribute atributo.

Imports System.AddIn.Contract
Imports System.AddIn.Pipeline

Namespace CalculatorContracts

    ' The AddInContractAttribute identifes this pipeline segment as a
    ' contract.
    <AddInContract()> _
    Public Interface ICalc1Contract
        Inherits IContract

        Function Add(ByVal a As Double, ByVal b As Double) As Double
        Function Subtract(ByVal a As Double, ByVal b As Double) As Double
        Function Multiply(ByVal a As Double, ByVal b As Double) As Double
        Function Divide(ByVal a As Double, ByVal b As Double) As Double
    End Interface

End Namespace

using System.AddIn.Contract;
using System.AddIn.Pipeline;

namespace CalculatorContracts
{
    // The AddInContractAttribute identifes this pipeline segment as a 
    // contract.
    [AddInContract]
    public interface ICalc1Contract : IContract
    {
    double Add(double a, double b);
    double Subtract(double a, double b);
    double Multiply(double a, double b);
    double Divide(double a, double b);
    }
}

Opcionalmente, crie a solução de Visual Studio. A solução não pode ser executada até que o último procedimento, mas a criá-lo depois de cada procedimento garante que cada projeto é corrigir.

Porque o modo de exibição do suplemento e o host do modo de exibição do suplemento geralmente têm o mesmo código, especialmente na primeira versão de um suplemento, 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, enquanto o modo de exibição de host do add-in não requer quaisquer atributos.

Para criar a exibição do suplemento

Adicionar um novo projeto chamado Calc1AddInView para o CalculatorV1 solução. Baseá-lo na Biblioteca de classe modelo.
Em Solution Explorer, adicione uma referência a System.AddIn.dll para o Calc1AddInView project.
Em Solution Explorer, excluir a classe padrão que é adicionada à nova Biblioteca de classe projetos e, em seguida, adicione um novo item ao projeto, usando o Interface modelo. No Add New Item caixa de diálogo, o nome da interface ICalculator.
No arquivo de interface, adicione uma referência ao namespace para System.AddIn.Pipeline.

Use o código a seguir para concluir este modo de exibição do suplemento. Observe que esta interface deve ter o AddInBaseAttribute atributo.

Imports System.AddIn.Pipeline

Namespace CalcAddInViews

    ' The AddInBaseAttribute identifes this interface as the basis for the
    ' add-in view pipeline segment.
    <AddInBaseAttribute()> _
    Public Interface ICalculator

        Function Add(ByVal a As Double, ByVal b As Double) As Double
        Function Subtract(ByVal a As Double, ByVal b As Double) As Double
        Function Multiply(ByVal a As Double, ByVal b As Double) As Double
        Function Divide(ByVal a As Double, ByVal b As Double) As Double
    End Interface

End Namespace

using System.AddIn.Pipeline;

namespace CalcAddInViews 
{
    // The AddInBaseAttribute identifes this interface as the basis for
    // the add-in view pipeline segment.
    [AddInBase()]
    public interface ICalculator 
    {
    double Add(double a, double b);
    double Subtract(double a, double b);
    double Multiply(double a, double b);
    double Divide(double a, double b);
    }
}

Opcionalmente, crie a solução de Visual Studio.

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

Adicionar um novo projeto chamado Calc1HVA para o CalculatorV1 solução. Baseá-lo na Biblioteca de classe modelo.
Em Solution Explorer, excluir a classe padrão que é adicionada à nova Biblioteca de classe projetos e, em seguida, adicione um novo item ao projeto, usando o Interface modelo. No Add New Item caixa de diálogo, o nome da interface ICalculator.

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

Namespace CalcHVAs

    Public Interface ICalculator
        Function Add(ByVal a As Double, ByVal b As Double) As Double
        Function Subtract(ByVal a As Double, ByVal b As Double) As Double
        Function Multiply(ByVal a As Double, ByVal b As Double) As Double
        Function Divide(ByVal a As Double, ByVal b As Double) As Double
    End Interface

End Namespace

namespace CalcHVAs 
{
    public interface ICalculator 
    {
        double Add(double a, double b);
        double Subtract(double a, double b);
        double Multiply(double a, double b);
        double Divide(double a, double b);
    }
}

Opcionalmente, crie a solução de Visual Studio.

Criação do adaptador de adicionar no lado

Este adaptador de adicionar no lado consiste em um adaptador de exibição para o contrato. Neste segmento de pipeline converte os tipos no modo de exibição add-in para o contrato.

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 do lado do suplemento desse pipeline.

Para criar o adaptador de adicionar no lado

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

System.addin.dll

System.addin.Contract.dll
Adicione referências de projeto para os projetos para os segmentos adjacentes do pipeline:

Calc1AddInView

Calc1Contract
Selecione cada referência de projeto e em Propriedades set Copy Local para False. 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 referências a 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 Calc1Contract.CalculatorContracts, a menos que você tenha desativado os namespaces padrão em seus projetos de Visual Basic.)
Aplicar o AddInAdapterAttribute de atributo para o CalculatorViewToContractAddInSideAdapter classe, para identificá-lo como o adaptador de lado em Adicionar.
Verifique o CalculatorViewToContractAddInSideAdapter herdam da classe ContractBase, que fornece uma implementação padrão da IContract interface e implementar a interface de contrato para o pipeline, ICalc1Contract.
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 ICalc1Contract, basta chamar os membros correspondentes a ICalculator instância que é passada para o construtor e retorna os resultados. Isso se adapta o modo de exibição (ICalculator) para o contrato (ICalc1Contract).

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

Imports System.AddIn.Pipeline
Imports Calc1AddInView.CalcAddInViews
Imports Calc1Contract.CalculatorContracts

Namespace CalcAddInSideAdapters

    ' The AddInAdapterAttribute identifes this class as the add-in-side 
    ' adapter pipeline segment.
    <AddInAdapter()> _
    Public Class CalculatorViewToContractAddInSideAdapter
        Inherits ContractBase
        Implements ICalc1Contract

        Private _view As ICalculator

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

        Public Function Add(ByVal a As Double, ByVal b As Double) As Double Implements ICalc1Contract.Add
            Return _view.Add(a, b)
        End Function

        Public Function Subtract(ByVal a As Double, ByVal b As Double) As Double Implements ICalc1Contract.Subtract
            Return _view.Subtract(a, b)
        End Function

        Public Function Multiply(ByVal a As Double, ByVal b As Double) As Double Implements ICalc1Contract.Multiply
            Return _view.Multiply(a, b)
        End Function

        Public Function Divide(ByVal a As Double, ByVal b As Double) As Double Implements ICalc1Contract.Divide
            Return _view.Divide(a, b)
        End Function

    End Class
End Namespace

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

namespace CalcAddInSideAdapters 
{
    // The AddInAdapterAttribute identifes this class as the add-in-side adapter
    // pipeline segment.
    [AddInAdapter()]
    public class CalculatorViewToContractAddInSideAdapter :
        ContractBase, ICalc1Contract 
    {
        private ICalculator _view;

        public CalculatorViewToContractAddInSideAdapter(ICalculator view) 
        {
            _view = view;
        }

        public virtual double Add(double a, double b) 
        {
            return _view.Add(a, b);
        }

        public virtual double Subtract(double a, double b) 
        {
            return _view.Subtract(a, b);
        }

        public virtual double Multiply(double a, double b) 
        {
            return _view.Multiply(a, b);
        }

        public virtual double Divide(double a, double b) 
        {
            return _view.Divide(a, b);
        }
    }
}

Opcionalmente, crie a solução de Visual Studio.

Criando o adaptador de Host

Este adaptador de host consiste em um adaptador de exibição de contrato. Esse segmento adapta o contrato para o modo de exibição de host do add-in.

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 Calc1HostSideAdapter para o CalculatorV1 solução. Baseá-lo na Biblioteca de classe modelo.
Em Solution Explorer, adicionar referências aos seguintes assemblies para o Calc1HostSideAdapter projeto:

System.addin.dll

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

Calc1Contract

Calc1HVA
Selecione cada referência de projeto e em Propriedades set Copy Local para False. 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 Calc1HVA.CalcHVAs e Calc1Contract.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 segmento do adaptador no lado do host.
Verifique o CalculatorContractToViewHostSideAdapter a classe implementa a interface que representa o modo de exibição de host do add-in: Calc1HVAs.ICalculator (Calc1HVA.CalcHVAs.ICalculator em Visual Basic).
Adicionar um construtor público que aceita o tipo de contrato de pipeline, ICalc1Contract. 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.

Para implementar os membros da ICalculator, basta chamar os membros correspondentes a ICalc1Contract instância que é passada para o construtor e retorna os resultados. Isso se adapta o contrato (ICalc1Contract) no modo de exibição (ICalculator).

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

Imports System.AddIn.Pipeline
Imports Calc1Contract.CalculatorContracts
Imports Calc1HVA.CalcHVAs

Namespace CalcHostSideAdapters

    ' The HostAdapterAttribute identifes this class as the host-side adapter
    ' pipeline segment.
    <HostAdapterAttribute()> _
    Public Class CalculatorContractToViewHostSideAdapter
        Implements ICalculator

        Private _contract As ICalc1Contract
        Private _handle As System.AddIn.Pipeline.ContractHandle

        Public Sub New(ByVal contract As ICalc1Contract)
                MyBase.New()
            _contract = contract
            _handle = New ContractHandle(contract)
        End Sub

        Public Function Add(ByVal a As Double, ByVal b As Double) As Double _
                Implements ICalculator.Add
            Return _contract.Add(a, b)
        End Function

        Public Function Subtract(ByVal a As Double, ByVal b As Double) As Double _
                Implements ICalculator.Subtract
            Return _contract.Subtract(a, b)
        End Function

        Public Function Multiply(ByVal a As Double, ByVal b As Double) As Double _
                Implements ICalculator.Multiply
            Return _contract.Multiply(a, b)
        End Function

        Public Function Divide(ByVal a As Double, ByVal b As Double) As Double _
                Implements ICalculator.Divide
            Return _contract.Divide(a, b)
        End Function

    End Class

End Namespace

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

namespace CalcHostSideAdapters 
{
    // The HostAdapterAttribute identifes this class as the host-side adapter
    // pipeline segment.
    [HostAdapterAttribute()]
    public class CalculatorContractToViewHostSideAdapter : ICalculator 
    {
        private ICalc1Contract _contract;
        private System.AddIn.Pipeline.ContractHandle _handle;

        public CalculatorContractToViewHostSideAdapter(ICalc1Contract contract) 
        {
            _contract = contract;
            _handle = new ContractHandle(contract);
        }

        public double Add(double a, double b) 
        {
            return _contract.Add(a, b);
        }

        public double Subtract(double a, double b) 
        {
            return _contract.Subtract(a, b);
        }

        public double Multiply(double a, double b) 
        {
            return _contract.Multiply(a, b);
        }

        public double Divide(double a, double b) 
        {
            return _contract.Divide(a, b);
        }
    }
}

Opcionalmente, crie a solução de Visual Studio.

Criação do Host

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

Atualize o cache das informações de pipeline e o suplemento.
Localizar suplementos de tipo de exibição de host, ICalculator, com o pipeline diretório da raiz.
Solicite ao usuário especificar qual suplemento para usar.
Ative o suplemento selecionado em um novo domínio de aplicativo com um nível de confiança de segurança especificado.
Execute o custom RunCalculator método, que chama os métodos do suplemento, conforme especificado pela exibição do host do add-in.

Para criar o host

Adicionar um novo projeto chamado Calc1Host para o CalculatorV1 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 Calc1Host project.
Adicione uma referência para o Calc1HVA project. Selecione a referência de projeto e em Propriedades set Copy Local para False. 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) MathHost1.
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 o modo de exibição de host do add-in: CalcHVAs. (Visual Basic, essa referência ao namespace é Calc1HVA.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.

No arquivo de classe ou módulo, use o AddInStore.Update método para atualizar o cache. Use o AddInStore.FindAddIn método para obter uma coleção de tokens e usar o AddInToken.Activate método para ativar um add-in.

O código a seguir mostra o aplicativo de host completo.

Imports System.Collections.Generic
Imports System.Collections.ObjectModel
Imports System.AddIn.Hosting
Imports Calc1HVA.CalcHVAs

Namespace MathHost

    Module MathHost1

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

            ' Update the cache files of the pipeline segments and add-ins.
            Dim warnings() As String = AddInStore.Update(addInRoot)
            For Each warning As String In warnings
                Console.WriteLine(warning)
            Next

            ' Search for add-ins of type ICalculator (the host view of the add-in).
            Dim tokens As System.Collections.ObjectModel.Collection(Of AddInToken) = _
                AddInStore.FindAddIns(GetType(ICalculator), addinRoot)

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

            ' Activate the selected AddInToken in a new application domain 
            ' with the Internet trust level.
            Dim calc As ICalculator = _
                calcToken.Activate(Of ICalculator)(AddInSecurityLevel.Internet)

            ' Run the add-in.
            RunCalculator(calc)
        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 ICalculator)
            If IsNothing(calc) Then
                'No calculators were found, read a line and exit.
                Console.ReadLine()
            End If
            Console.WriteLine("Available operations: +, -, *, /")
            Console.WriteLine("Request a calculation , such as: 2 + 2")
            Console.WriteLine("Type 'exit' to exit")
            Dim line As String = Console.ReadLine

            While Not line.Equals("exit")
                ' The Parser class parses the user's input.
                Try
                    Dim c As Parser = New Parser(line)
                    Select Case (c.action)
                        Case "+"
                            Console.WriteLine(calc.Add(c.a, c.b))
                        Case "-"
                            Console.WriteLine(calc.Subtract(c.a, c.b))
                        Case "*"
                            Console.WriteLine(calc.Multiply(c.a, c.b))
                        Case "/"
                            Console.WriteLine(calc.Divide(c.a, c.b))
                        Case Else
                            Console.WriteLine("{0} is an invalid command. Valid commands are +,-,*,/", c.action)
                    End Select
                Catch Ex As System.Exception
                    Console.WriteLine("Invalid command: {0}. Commands must be formated: [number] [operation] [number]", line)
                End Try
                line = Console.ReadLine

            End While
        End Sub
    End Module

    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.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";

            // Update the cache files of the pipeline segments and add-ins.
            string[] warnings = AddInStore.Update(addInRoot);
            foreach (string warning in warnings)
            {
                Console.WriteLine(warning);
            }

            // Search for add-ins of type ICalculator (the host view of the add-in).
            Collection<AddInToken> tokens = 
                AddInStore.FindAddIns(typeof(ICalculator), 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.
            ICalculator calc = 
                calcToken.Activate<ICalculator>(AddInSecurityLevel.Internet);

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

        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(ICalculator calc)
        {

            if (calc == null)
            {
                //No calculators were found; read a line and exit.
                Console.ReadLine();
            }
            Console.WriteLine("Available operations: +, -, *, /");
            Console.WriteLine("Request a calculation , such as: 2 + 2");
            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);
                    switch (c.Action)
                    {
                        case "+":
                            Console.WriteLine(calc.Add(c.A, c.B));
                            break;
                        case "-":
                            Console.WriteLine(calc.Subtract(c.A, c.B));
                            break;
                        case "*":
                            Console.WriteLine(calc.Multiply(c.A, c.B));
                            break;
                        case "/":
                            Console.WriteLine(calc.Divide(c.A, c.B));
                            break;
                        default:
                            Console.WriteLine("{0} is an invalid command. Valid commands are +,-,*,/", c.Action);
                            break;
                    }
                }
                catch
                {
                    Console.WriteLine("Invalid command: {0}. Commands must be formated: [number] [operation] [number]", line);
                }

                line = Console.ReadLine();
            }
        }
    }

    internal class Parser
    {
        double a;
        double b;
        string action;

        internal Parser(string line)
        {
            string[] parts = line.Split(' ');
            a = double.Parse(parts[0]);
            action = parts[1];
            b = double.Parse(parts[2]);
        }

        public double A
        {
            get { return a; }
        }

        public double B
        {
            get { return b; }
        }

        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.

O código usa um ChooseCalculator método para listar os tokens e solicitar que o usuário escolha um add-in. O RunCalculator método solicita ao usuário para expressões matemáticas simples, analisa as expressões usando o Parser classe e exibe os resultados retornados pelo add-in.

Opcionalmente, crie a solução de Visual Studio.

Criando o suplemento

Um suplemento implementa os métodos especificados pelo modo de exibição do suplemento. Este suplemento implementa o Add, Subtract, Multiply, e Divide operações e retorna os resultados para o host.

Para criar o suplemento

Adicionar um novo projeto chamado AddInCalcV1 para o CalculatorV1 solução. Baseá-lo na Biblioteca de classe modelo.
Em Solution Explorer, adicione uma referência ao assembly System.AddIn.dll para o projeto.
Adicione uma referência para o Calc1AddInView project. Selecione a referência de projeto e em Propriedades, defina Copy Local para False. No Visual Basic, use o referências guia de Propriedades do projeto para definir Copy Local para False para a referência de projeto.
Renomeie a classe AddInCalcV1.
No arquivo de classe, adicione uma referência ao namespace para System.AddIn e o segmento de exibição do suplemento: CalcAddInViews (Calc1AddInView.CalcAddInViews em Visual Basic).
Aplicar o AddInAttribute de atributo para o AddInCalcV1 classe, para identificar a classe como um add-in.
Verifique o AddInCalcV1 a classe implementa a interface que representa o modo de exibição do suplemento: CalcAddInViews.ICalculator (Calc1AddInView.CalcAddInViews.ICalculator em Visual Basic).

Implementar os membros da ICalculator , retornando os resultados dos cálculos apropriados.

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

Imports System.AddIn
Imports Calc1AddInView.CalcAddInViews

Namespace CalcAddIns

    ' The AddInAttribute identifies this pipeline segment as an add-in.
    <AddIn("Calculator AddIn", Version:="1.0.0.0")> _
    Public Class AddInCalcV1
        Implements ICalculator

        Public Function Add(ByVal a As Double, ByVal b As Double) As Double _
                Implements ICalculator.Add
            Return (a + b)
        End Function

        Public Function Subtract(ByVal a As Double, ByVal b As Double) As Double _
                Implements ICalculator.Subtract
            Return (a - b)
        End Function

        Public Function Multiply(ByVal a As Double, ByVal b As Double) As Double _
                Implements ICalculator.Multiply
            Return (a * b)
        End Function

        Public Function Divide(ByVal a As Double, ByVal b As Double) As Double _
                Implements ICalculator.Divide
            Return (a / b)
        End Function
    End Class

End Namespace

using System.Collections.Generic;
using System.AddIn;
using CalcAddInViews;

namespace CalcAddIns
{
    // The AddInAttribute identifies this pipeline segment as an add-in.
    [AddIn("Calculator AddIn",Version="1.0.0.0")]
    public class AddInCalcV1 : ICalculator
    {
        public double Add(double a, double b)
        {
            return a + b;
        }

        public double Subtract(double a, double b)
        {
            return a - b;
        }

        public double Multiply(double a, double b)
        {
            return a * b;
        }

        public double Divide(double a, double b)
        {
            return a / b;
        }
    }
}

Opcionalmente, crie a solução de Visual Studio.

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
AddInCalcV1	MyApp\Pipeline\AddIns\CalcV1
Calc1AddInSideAdapter	MyApp\Pipeline\AddInSideAdapters
Calc1AddInView	MyApp\Pipeline\AddInViews
Calc1Contract	MyApp\Pipeline\Contracts
Calc1Host	MyApp
Calc1HostSideAdapter	MyApp\Pipeline\HostSideAdapters
Calc1HVA	MyApp

Observação

Se você decidir colocar sua estrutura de pastas de pipeline em um local diferente da pasta do seu aplicativo, você deve modificar os caminhos mostrados na tabela de acordo.Consulte a discussão de requisitos do diretório de pipeline em Requisitos de desenvolvimento de pipeline.

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 Calc1AddInView referência de projeto de AddInCalcV1 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 o suplemento.

Para executar o aplicativo host

No prompt de comando, vá para o diretório de aplicativo e executar o aplicativo host, Calc1Host.exe.
O host localiza todos os suplementos disponíveis do seu tipo e solicita que você selecione um add-in. Digite 1 para o suplemento só está disponível.
Insira uma equação para a Calculadora, como, por exemplo, 2 + 2. Deve haver espaços entre os números e o operador.
Digite exit e pressione o Enter chave para fechar o aplicativo.

Consulte também

Tarefas

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

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: Criando um aplicativo extensível

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 criar a exibição de host do add-in

Criação do adaptador de adicionar no lado

Para criar o adaptador de adicionar no lado

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