Partilhar via


Demonstra Passo a passo: Criando um aplicativo extensível

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

  1. Em Visual Studio, crie um novo projeto chamado Calc1Contract. Baseá-lo na Biblioteca de classe modelo.

  2. 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

  1. Crie uma pasta de aplicativo em qualquer lugar no seu computador.

  2. 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.

  1. Na solução de Visual Studio chamada CalculatorV1, abra o Calc1Contract project.

  2. Em Solution Explorer, adicionar referências aos seguintes assemblies para o Calc1Contract projeto:

    System.addin.Contract.dll

    System.addin.dll

  3. Em Solution Explorer, excluir a classe padrão que é adicionada à nova Biblioteca de classe projetos.

  4. 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.

  5. O arquivo de interface Adicionar referências a namespace para System.AddIn.Contract e System.AddIn.Pipeline.

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

  1. Adicionar um novo projeto chamado Calc1AddInView para o CalculatorV1 solução. Baseá-lo na Biblioteca de classe modelo.

  2. Em Solution Explorer, adicione uma referência a System.AddIn.dll para o Calc1AddInView project.

  3. 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.

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

  5. 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);
        }
    }
    
  6. Opcionalmente, crie a solução de Visual Studio.

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

  1. Adicionar um novo projeto chamado Calc1HVA para o CalculatorV1 solução. Baseá-lo na Biblioteca de classe modelo.

  2. 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.

  3. 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);
        }
    }
    
  4. 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

  1. Adicionar um novo projeto chamado Calc1AddInSideAdapter para o CalculatorV1 solução. Baseá-lo na Biblioteca de classe modelo.

  2. Em Solution Explorer, adicionar referências aos seguintes assemblies para o Calc1AddInSideAdapter projeto:

    System.addin.dll

    System.addin.Contract.dll

  3. Adicione referências de projeto para os projetos para os segmentos adjacentes do pipeline:

    Calc1AddInView

    Calc1Contract

  4. 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.

  5. Renomeie a classe do projeto padrão CalculatorViewToContractAddInSideAdapter.

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

  7. 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.)

  8. Aplicar o AddInAdapterAttribute de atributo para o CalculatorViewToContractAddInSideAdapter classe, para identificá-lo como o adaptador de lado em Adicionar.

  9. 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.

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

  11. 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);
            }
        }
    }
    
  12. 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

  1. Adicionar um novo projeto chamado Calc1HostSideAdapter para o CalculatorV1 solução. Baseá-lo na Biblioteca de classe modelo.

  2. Em Solution Explorer, adicionar referências aos seguintes assemblies para o Calc1HostSideAdapter projeto:

    System.addin.dll

    System.addin.Contract.dll

  3. Adicione referências de projeto para os projetos para os segmentos adjacentes:

    Calc1Contract

    Calc1HVA

  4. 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.

  5. Renomeie a classe do projeto padrão CalculatorContractToViewHostSideAdapter.

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

  7. 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.)

  8. Aplicar o HostAdapterAttribute de atributo para o CalculatorContractToViewHostSideAdapter classe, para identificá-lo como o segmento do adaptador no lado do host.

  9. 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).

  10. 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.

  11. 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);
            }
        }
    }
    
  12. 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

  1. Adicionar um novo projeto chamado Calc1Host para o CalculatorV1 solução. Baseá-lo sobre o O aplicativo de Console modelo.

  2. Em Solution Explorer, adicione uma referência ao assembly System.AddIn.dll para o Calc1Host project.

  3. 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.

  4. Renomeie o arquivo de classe (módulo de Visual Basic) MathHost1.

  5. 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.

  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 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.)

  8. 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.

  9. 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.

  10. 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

  1. Adicionar um novo projeto chamado AddInCalcV1 para o CalculatorV1 solução. Baseá-lo na Biblioteca de classe modelo.

  2. Em Solution Explorer, adicione uma referência ao assembly System.AddIn.dll para o projeto.

  3. 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.

  4. Renomeie a classe AddInCalcV1.

  5. 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).

  6. Aplicar o AddInAttribute de atributo para o AddInCalcV1 classe, para identificar a classe como um add-in.

  7. 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).

  8. 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;
            }
        }
    }
    
  9. 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

  1. 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.

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

    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

  1. No prompt de comando, vá para o diretório de aplicativo e executar o aplicativo host, Calc1Host.exe.

  2. 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.

  3. Insira uma equação para a Calculadora, como, por exemplo, 2 + 2. Deve haver espaços entre os números e o operador.

  4. 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