Share via

Demonstra Passo a passo: Criando um aplicativo extensível

  • Artigo

Esta explicação passo a passo descreve como criar um pipeline para um suplemento que executa funções simples de Calculadora.Ele não demonstram um cenário 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 do Visual Studio.

  • Criando a estrutura de diretório do pipeline.

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

  • Criando o adaptador no lado do suplemento.

  • Criando o adaptador do host.

  • Criando o host.

  • Criando o add-no.

  • Implantando o pipeline.

  • Executar o aplicativo host.

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

O contrato esse pipeline define um modelo de objeto de quatro operações aritméticas: Adicionar, subtrair, multiplicar e dividir.O host fornece o suplemento com uma equação para calcular, sistema autônomo 2 + 2 e o suplemento retorna o resultado para o host.

Versão 2 do suplemento Calculadora fornece cálculo mais possibilidades e demonstra o controle de versão.Ele está descrito no Demonstra Passo a passo: Ativar compatibilidade com versões anteriores, sistema autônomo sistema autônomo alterações de host.

Observação:

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

Pré-requisitos

O seguinte para concluir esta explicação passo a passo, você precisa:

  • Visual Studio.

Criando uma solução do Visual Studio

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

Para criar a solução de pipeline

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

  2. Nomeie a solução CalculatorV1.

Criando a estrutura de diretório de pipeline

O modelo de suplemento requer os assemblies de segmento pipeline a ser colocado em uma estrutura de diretórios especificada.Para obter mais informações sobre a estrutura de pipeline, consulte Requisitos de desenvolvimento de pipeline.

Para criar a estrutura de diretório de pipeline

  1. criar 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 da pasta pipeline na sua pasta de aplicativo; ele é concluído aqui somente por conveniência.Na etapa de apropriado, o explicação passo a passo explica como alterar o código se a estrutura da pasta pipeline estiver em um local diferente.Consulte a discussão de requisitos pipeline diretório 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: Ativar compatibilidade com versões anteriores, sistema autônomo sistema autônomo alterações de host.

Criação do contrato e exibições

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

Para criar o contrato

  1. Na solução Visual Studio chamada CalculatorV1, em aberto the Calc1Contractprojeto .

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

    sistema.AddIn.contrato.dll

    sistema.AddIn.dll

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

  4. In O gerenciador de soluções, adicionar um novo item ao projeto, usando o Interface modelo.No Adicionar novo item caixa de diálogo, a interface nomeICalc1Contract.

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

  6. Use o código a seguir para concluir 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 do Visual Studio.A solução não pode ser executada até que corrija o procedimento final, mas criá-lo depois de cada procedimento garante que cada projeto.

Porque o exibição de suplemento e a exibição do host do add-in geralmente possuem o mesmo código, especialmente na primeira versão de um suplemento, você poderá criar com facilidade os modos de exibição ao mesmo time.Diferem em apenas um fator: o modo de exibição de suplemento requer o AddInBaseAttribute atributo, enquanto a exibição do host do suplemento não requer quaisquer atributos.

Para criar exibição de suplemento

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

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

  3. In O gerenciador de soluções, excluir a classe padrão que é adicionada à nova biblioteca de classes projetos e adicione um novo item ao projeto, usando o Interface modelo.No Adicionar novo item caixa de diálogo, a interface nomeICalculator.

  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 do Visual Studio.

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

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

  2. In O gerenciador de soluções, excluir a classe padrão que é adicionada à nova biblioteca de classes projetos e adicione um novo item ao projeto, usando o Interface modelo.No Adicionar novo item caixa de diálogo, a interface nomeICalculator.

  3. No arquivo de interface, use o código a seguir para concluir o modo de exibição do host a suplemento.

    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 do Visual Studio.

Criando o adaptador no lado do suplemento

Isso adaptador no lado do suplemento consiste em um adaptador do tipo exibição-para-contrato.Esse segmento de pipeline converte os tipos de exibição de suplemento ao contrato.

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

Para criar o adaptador no lado do suplemento

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

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

    sistema.AddIn.dll

    sistema.AddIn.contrato.dll

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

    Calc1AddInView

    Calc1Contract

  4. selecionar cada referência de projeto e em Propriedades conjunto Copiar local to False.No Visual Basic, utilize o Referências guia of Propriedades do projeto to conjunto Copiar local to False as referências de dois projeto.

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

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

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

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

  9. Verifique o CalculatorViewToContractAddInSideAdapter Herdar de classe ContractBase, que fornece uma implementação padrão das 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 privado e chama o construtor da classe base.

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

    O código a seguir mostra o adaptador 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 do Visual Studio.

Criando o adaptador no lado do host

Este adaptador do host é composto de um adaptador de contrato-para-exibição.Esse segmento se adapta o contrato para o modo de exibição de host do suplemento.

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

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

Para criar o adaptador do host

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

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

    sistema.AddIn.dll

    sistema.AddIn.contrato.dll

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

    Calc1Contract

    Calc1HVA

  4. selecionar cada referência de projeto e em Propriedades conjunto Copiar local to False.No Visual Basic, utilize o Referências guia of Propriedades do projeto to conjunto Copiar local to False as referências de dois projeto.

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

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

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

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

  9. Verifique o CalculatorContractToViewHostSideAdapter classe implementa a interface que representa o modo de exibição do host a suplemento: Calc1HVAs.ICalculator (Calc1HVA.CalcHVAs.ICalculator no 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 um novo ContractHandle para o contrato para gerenciar o ciclo de vida do suplemento.

    Observação importante:

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

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

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

    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 do Visual Studio.

Criando o host

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

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

  • Localizar suplementos de tipo de modo de exibição de host, ICalculator, no diretório raiz do pipeline especificado.

  • Solicita que o usuário especifique quais suplemento usar.

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

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

Para criar o host

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

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

  3. Adicionar uma referência de projeto para o Calc1HVA projeto. selecionar a referência de projeto e em Propriedades conjunto Copiar local to False.No Visual Basic, utilize o Referências guia of Propriedades do projeto to conjunto Copiar local to False.

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

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

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

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

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

  9. No arquivo de classe ou módulo, utilize 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 suplemento.

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

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

    O código usa um ChooseCalculator método para listar os tokens e solicitar ao usuário escolher um suplemento. The 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 por suplemento.

  10. Opcionalmente, crie a solução do Visual Studio.

Criando o suplemento

Um suplemento implementa os métodos especificados pelo exibição de 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 denominado AddInCalcV1 to the CalculatorV1 solução.Basear o biblioteca de classes modelo.

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

  3. Adicionar uma referência de projeto para o Calc1AddInViewprojeto .selecionar a referência de projeto e em Propriedades, conjunto Copiar local to False.No Visual Basic, utilize o Referências guia of Propriedades do projeto to conjunto Copiar local to False para a referência de projeto.

  4. Renomeie a classe AddInCalcV1.

  5. No arquivo classe, adicione uma referência ao namespace para System.AddIn e o exibição de suplemento segmento: CalcAddInViews (Calc1AddInView.CalcAddInViews no Visual Basic).

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

  7. Verifique o AddInCalcV1 classe implementa a interface que representa o modo de exibição do suplemento: CalcAddInViews.ICalculator (Calc1AddInView.CalcAddInViews.ICalculator no Visual Basic).

  8. Implemente os membros de 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 do Visual Studio.

Implantando o pipeline

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

Para distribuir os segmentos para o pipeline

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

    Project

    Caminho

    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 seu estrutura de pastas de pipeline no um local diferente sua pasta de aplicativo , você deve modificar os caminhos mostrados na tabela adequadamente .Consulte a discussão de requisitos de diretório de pipeline no Requisitos de desenvolvimento de pipeline.

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

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

    Observação:

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

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

Executando o aplicativo host

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

Para executar aplicativo host

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

  2. Ele localiza todos os suplementos disponível do seu tipo e solicita que você selecionar um suplemento.Digite 1 para o suplemento só está disponível.

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

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

Consulte também

Tarefas

Demonstra Passo a passo: Ativar compatibilidade com versões anteriores, sistema autônomo sistema autônomo 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

Date

History

Motivo

Julho de 2008

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

Comentários do cliente.