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
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: Coleções de passagem entre Hosts e suplementos
Conceitos
Requisitos de desenvolvimento de pipeline