Procedura dettagliata: creazione di un'applicazione estendibileWalkthrough: Creating an Extensible Application

Questa procedura dettagliata viene descritto come creare una pipeline per un componente aggiuntivo che esegue funzioni calcolatrice semplice.This walkthrough describes how to create a pipeline for an add-in that performs simple calculator functions. Viene illustrato uno scenario reale; invece, vengono illustrate le funzionalità di base di una pipeline e un componente aggiuntivo può come fornire servizi per un host.It does not demonstrate a real-world scenario; rather, it demonstrates the basic functionality of a pipeline and how an add-in can provide services for a host.

Questa procedura dettagliata vengono descritte le attività seguenti:This walkthrough describes the following tasks:

  • Creazione di una soluzione di Visual Studio.Creating a Visual Studio solution.

  • Creazione della struttura di directory della pipeline.Creating the pipeline directory structure.

  • Creazione del contratto e viste.Creating the contract and views.

  • Creazione dell'adattatore sul lato del componente aggiuntivo.Creating the add-in-side adapter.

  • Creazione dell'adattatore sul lato host.Creating the host-side adapter.

  • Creazione dell'host.Creating the host.

  • Creazione del componente aggiuntivo.Creating the add-in.

  • Distribuzione della pipeline.Deploying the pipeline.

  • Esecuzione dell'applicazione host.Running the host application.

Questa pipeline passa solo tipi serializzabili (Double e String), tra l'host e il componente aggiuntivo.This pipeline passes only serializable types (Double and String), between the host and the add-in. Per un esempio che illustra come passare raccolte di tipi di dati complessi, vedere procedura dettagliata: passaggio di raccolte tra host e Add-Ins.For an example that shows how to pass collections of complex data types, see Walkthrough: Passing Collections Between Hosts and Add-Ins.

Il contratto per la pipeline definisce un modello a oggetti di quattro operazioni aritmetiche: aggiungere, sottrarre, moltiplicare e dividere.The contract for this pipeline defines an object model of four arithmetic operations: add, subtract, multiply, and divide. L'host fornisce il componente aggiuntivo con un'equazione per calcolare, ad esempio 2 + 2 e il componente aggiuntivo restituisce il risultato all'host.The host provides the add-in with an equation to calculate, such as 2 + 2, and the add-in returns the result to the host.

Versione 2 del componente aggiuntivo calcolatrice fornisce maggiori possibilità di calcolo e viene illustrato il controllo delle versioni.Version 2 of the calculator add-in provides more calculating possibilities and demonstrates versioning. Viene descritto in procedura dettagliata: abilitare la compatibilità come le modifiche di Host.It is described in Walkthrough: Enabling Backward Compatibility as Your Host Changes.

PrerequisitiPrerequisites

Per completare questa procedura dettagliata, sono necessari i seguenti elementi:You need the following to complete this walkthrough:

  • Visual Studio.Visual Studio.

Creazione di una soluzione di Visual StudioCreating a Visual Studio Solution

Usare una soluzione in Visual Studio per contenere i progetti dei segmenti di pipeline.Use a solution in Visual Studio to contain the projects of your pipeline segments.

Per creare la soluzione di pipelineTo create the pipeline solution

  1. In Visual Studio, creare un nuovo progetto denominato Calc1Contract.In Visual Studio, create a new project named Calc1Contract. Come base il libreria di classi modello.Base it on the Class Library template.

  2. Denominare la soluzione CalculatorV1.Name the solution CalculatorV1.

Creazione della struttura di Directory della PipelineCreating the Pipeline Directory Structure

Il modello di componente aggiuntivo richiede gli assembly dei segmenti della pipeline si trovino in una struttura di directory specificato.The add-in model requires the pipeline segment assemblies to be placed in a specified directory structure. Per ulteriori informazioni sulla struttura della pipeline, vedere requisiti di sviluppo Pipeline.For more information about the pipeline structure, see Pipeline Development Requirements.

Per creare la struttura di directory della pipelineTo create the pipeline directory structure

  1. Creare una cartella dell'applicazione in un punto qualsiasi nel computer in uso.Create an application folder anywhere on your computer.

  2. In tale cartella, creare la struttura seguente:In that folder, create the following structure:

    Pipeline  
      AddIns  
        CalcV1  
        CalcV2  
      AddInSideAdapters  
      AddInViews  
      Contracts  
      HostSideAdapters  
    

    Non è necessario inserire la struttura di cartelle della pipeline nella cartella dell'applicazione; viene eseguita qui solo per comodità.It is not necessary to put the pipeline folder structure in your application folder; it is done here only for convenience. Nel passaggio appropriato, la procedura dettagliata viene illustrato come modificare il codice se la struttura di cartelle della pipeline si trova in un percorso diverso.At the appropriate step, the walkthrough explains how to change the code if the pipeline folder structure is in a different location. Vedere la sezione requisiti della pipeline directory requisiti di sviluppo Pipeline.See the discussion of pipeline directory requirements in Pipeline Development Requirements.

    Nota

    Il CalcV2 cartella non viene usata in questa procedura dettagliata, è un segnaposto per procedura dettagliata: abilitare la compatibilità come le modifiche di Host.The CalcV2 folder is not used in this walkthrough; it is a placeholder for Walkthrough: Enabling Backward Compatibility as Your Host Changes.

Creazione del contratto e visteCreating the Contract and Views

Definisce il segmento dei contratti per la pipeline di ICalc1Contract interfaccia che definisce i quattro metodi: add, subtract, multiply, e divide.The contract segment for this pipeline defines the ICalc1Contract interface, which defines four methods: add, subtract, multiply, and divide.

Per creare il contrattoTo create the contract

  1. Nella soluzione di Visual Studio denominata CalculatorV1, aprire il Calc1Contract progetto.In the Visual Studio solution named CalculatorV1, open the Calc1Contract project.

  2. In Esplora, aggiungere riferimenti agli assembly riportati di seguito per il Calc1Contract progetto:In Solution Explorer, add references to the following assemblies to the Calc1Contract project:

    System.AddIn.Contract.dllSystem.AddIn.Contract.dll

    System.AddIn.dllSystem.AddIn.dll

  3. In Esplora, escludere la classe predefinita che viene aggiunto al nuovo libreria di classi progetti.In Solution Explorer, exclude the default class that is added to new Class Library projects.

  4. In Esplora, aggiungere un nuovo elemento al progetto, tramite il interfaccia modello.In Solution Explorer, add a new item to the project, using the Interface template. Nel Aggiungi nuovo elemento nella finestra di dialogo Nome l'interfaccia ICalc1Contract.In the Add New Item dialog box, name the interface ICalc1Contract.

  5. Nel file di interfaccia, aggiungere riferimenti a spazi dei nomi per System.AddIn.Contract e System.AddIn.Pipeline.In the interface file, add namespace references to System.AddIn.Contract and System.AddIn.Pipeline.

  6. Utilizzare il codice seguente per completare questo segmento del contratto.Use the following code to complete this contract segment. Si noti che questa interfaccia deve avere il AddInContractAttribute attributo.Note that this interface must have the AddInContractAttribute attribute.

    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);
        }
    }
    
    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
    
  7. Facoltativamente, compilare la soluzione di Visual Studio.Optionally, build the Visual Studio solution. Impossibile eseguire la soluzione fino a quando la procedura finale, ma la compilazione al termine di ogni procedura garantisce che ogni progetto sia correggere.The solution cannot be run until the final procedure, but building it after each procedure ensures that each project is correct.

Poiché la vista del componente aggiuntivo e la visualizzazione host del componente aggiuntivo è in genere presentano lo stesso codice, in particolare nella prima versione di un componente aggiuntivo, è possibile creare facilmente le viste nello stesso momento.Because the add-in view and the host view of the add-in usually have the same code, especially in the first version of an add-in, you can easily create the views at the same time. Si differenziano per un solo fattore: la vista del componente aggiuntivo richiede il AddInBaseAttribute attributo, mentre la visualizzazione host del componente aggiuntivo non richiede attributi.They differ by only one factor: the add-in view requires the AddInBaseAttribute attribute, while the host view of the add-in does not require any attributes.

Per creare la vista del componente aggiuntivoTo create the add-in view

  1. Aggiungere un nuovo progetto denominato Calc1AddInView per il CalculatorV1 soluzione.Add a new project named Calc1AddInView to the CalculatorV1 solution. Come base il libreria di classi modello.Base it on the Class Library template.

  2. In Esplora, aggiungere un riferimento a System.AddIn.dll per il Calc1AddInView progetto.In Solution Explorer, add a reference to System.AddIn.dll to the Calc1AddInView project.

  3. In Esplora, escludere la classe predefinita che viene aggiunto al nuovo libreria di classi progetti e aggiungere un nuovo elemento al progetto, tramite il interfaccia modello.In Solution Explorer, exclude the default class that is added to new Class Library projects, and add a new item to the project, using the Interface template. Nel Aggiungi nuovo elemento nella finestra di dialogo Nome l'interfaccia ICalculator.In the Add New Item dialog box, name the interface ICalculator.

  4. Nel file di interfaccia, aggiungere un riferimento dello spazio dei nomi System.AddIn.Pipeline.In the interface file, add a namespace reference to System.AddIn.Pipeline.

  5. Utilizzare il codice seguente per completare questa vista del componente aggiuntivo.Use the following code to complete this add-in view. Si noti che questa interfaccia deve avere il AddInBaseAttribute attributo.Note that this interface must have the AddInBaseAttribute attribute.

    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);
        }
    }
    
    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
    
  6. Facoltativamente, compilare la soluzione di Visual Studio.Optionally, build the Visual Studio solution.

Per creare la visualizzazione host del componente aggiuntivoTo create the host view of the add-in

  1. Aggiungere un nuovo progetto denominato Calc1HVA per il CalculatorV1 soluzione.Add a new project named Calc1HVA to the CalculatorV1 solution. Come base il libreria di classi modello.Base it on the Class Library template.

  2. In Esplora, escludere la classe predefinita che viene aggiunto al nuovo libreria di classi progetti e aggiungere un nuovo elemento al progetto, tramite il interfaccia modello.In Solution Explorer, exclude the default class that is added to new Class Library projects, and add a new item to the project, using the Interface template. Nel Aggiungi nuovo elemento nella finestra di dialogo Nome l'interfaccia ICalculator.In the Add New Item dialog box, name the interface ICalculator.

  3. Nel file di interfaccia, utilizzare il codice seguente per completare la visualizzazione host del componente aggiuntivo.In the interface file, use the following code to complete the host view of the add-in.

    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);
        }
    }
    
    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
    
  4. Facoltativamente, compilare la soluzione di Visual Studio.Optionally, build the Visual Studio solution.

Creazione dell'adattatore sul lato componente-Creating the Add-in-side Adapter

Questo adattatore sul lato componente-è costituito da una scheda visualizzazione-contratto.This add-in-side adapter consists of one view-to-contract adapter. Questo segmento di pipeline converte i tipi della vista del componente aggiuntivo per il contratto.This pipeline segment converts the types from the add-in view to the contract.

In questa pipeline, il componente aggiuntivo fornisce un servizio all'host e i tipi di flusso dal componente aggiuntivo per l'host.In this pipeline, the add-in provides a service to the host, and the types flow from the add-in to the host. Poiché non vengono passati tipi dall'host per il componente aggiuntivo, non è necessario includere un adattatore contratto-visualizzazione sul lato componente della pipeline.Because no types flow from the host to the add-in, you do not have to include a contract-to-view adapter on the add-in side of this pipeline.

Per creare l'adattatore lato del componente aggiuntivoTo create the add-in-side adapter

  1. Aggiungere un nuovo progetto denominato Calc1AddInSideAdapter per il CalculatorV1 soluzione.Add a new project named Calc1AddInSideAdapter to the CalculatorV1 solution. Come base il libreria di classi modello.Base it on the Class Library template.

  2. In Esplora, aggiungere riferimenti agli assembly riportati di seguito per il Calc1AddInSideAdapter progetto:In Solution Explorer, add references to the following assemblies to the Calc1AddInSideAdapter project:

    System.AddIn.dllSystem.AddIn.dll

    System.AddIn.Contract.dllSystem.AddIn.Contract.dll

  3. Aggiungere riferimenti ai progetti per i segmenti della pipeline adiacenti:Add project references to the projects for the adjacent pipeline segments:

    Calc1AddInView

    Calc1Contract

  4. Selezionare ogni riferimento a progetto e in proprietà impostare Copia localmente a False.Select each project reference, and in Properties set Copy Local to False. In Visual Basic, usare il riferimenti scheda della le proprietà del progetto impostare Copia localmente per False per i due riferimenti al progetto.In Visual Basic, use the References tab of Project Properties to set Copy Local to False for the two project references.

  5. Rinominare la classe del progetto predefinita CalculatorViewToContractAddInSideAdapter.Rename the project's default class CalculatorViewToContractAddInSideAdapter.

  6. Nel file di classe, aggiungere riferimenti a spazi dei nomi per System.AddIn.Pipeline.In the class file, add namespace references to System.AddIn.Pipeline.

  7. Nel file di classe, aggiungere riferimenti a spazi dei nomi per i segmenti adiacenti: CalcAddInViews e CalculatorContracts.In the class file, add namespace references for the adjacent segments: CalcAddInViews and CalculatorContracts. (In Visual Basic, questi riferimenti dello spazio dei nomi sono Calc1AddInView.CalcAddInViews e Calc1Contract.CalculatorContracts, a meno che non è stato disattivato gli spazi dei nomi predefinito nei progetti di Visual Basic.)(In Visual Basic, these namespace references are Calc1AddInView.CalcAddInViews and Calc1Contract.CalculatorContracts, unless you have turned off the default namespaces in your Visual Basic projects.)

  8. Applicare il AddInAdapterAttribute attributo il CalculatorViewToContractAddInSideAdapter (classe), per identificarla come adattatore sul lato del componente aggiuntivo.Apply the AddInAdapterAttribute attribute to the CalculatorViewToContractAddInSideAdapter class, to identify it as the add-in-side adapter.

  9. Rendere il CalculatorViewToContractAddInSideAdapter classe ereditare ContractBase, che fornisce un'implementazione predefinita del IContract di interfaccia e implementare l'interfaccia del contratto per la pipeline, ICalc1Contract.Make the CalculatorViewToContractAddInSideAdapter class inherit ContractBase, which provides a default implementation of the IContract interface, and implement the contract interface for the pipeline, ICalc1Contract.

  10. Aggiungere un costruttore pubblico che accetta un ICalculator, memorizza nella cache in un campo privato e chiama il costruttore di classe di base.Add a public constructor that accepts an ICalculator, caches it in a private field, and calls the base class constructor.

  11. Per implementare i membri di ICalc1Contract, è sufficiente chiamare i membri corrispondenti del ICalculator istanza che viene passato al costruttore e restituisce i risultati.To implement the members of ICalc1Contract, simply call the corresponding members of the ICalculator instance that is passed to the constructor, and return the results. In questo modo la visualizzazione (ICalculator) al contratto (ICalc1Contract).This adapts the view (ICalculator) to the contract (ICalc1Contract).

    Il codice seguente illustra l'adattatore sul lato componente-completato.The following code shows the completed add-in-side adapter.

    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);
            }
        }
    }
    
    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
    
  12. Facoltativamente, compilare la soluzione di Visual Studio.Optionally, build the Visual Studio solution.

Creazione dell'adattatore sul lato HostCreating the Host-side Adapter

Questo adattatore sul lato host è costituito da una scheda di contratto per visualizzare.This host-side adapter consists of one contract-to-view adapter. Questo segmento adatta il contratto per la visualizzazione host del componente aggiuntivo.This segment adapts the contract to the host view of the add-in.

Nella pipeline, il componente aggiuntivo fornisce un servizio per l'host e il flusso di tipi di componente aggiuntivo per l'host.In this pipeline, the add-in provides a service to the host and the types flow from the add-in to the host. Poiché non vengono passati tipi dall'host per il componente aggiuntivo, non è necessario includere un adattatore visualizzazione-contratto.Because no types flow from the host to the add-in, you do not have to include a view-to-contract adapter.

Per implementare la gestione della durata, utilizzare un ContractHandle oggetto per associare un token di durata per il contratto.To implement lifetime management, use a ContractHandle object to attach a lifetime token to the contract. È necessario mantenere un riferimento a questo punto di controllo affinché le operazioni di gestione della durata.You must keep a reference to this handle in order for lifetime management to work. Dopo il token viene applicato, alcuna programmazione aggiuntiva non è necessaria perché il sistema del componente aggiuntivo è possibile eliminare gli oggetti quando non è più in uso e renderli disponibili per l'operazione di garbage collection.After the token is applied, no additional programming is required because the add-in system can dispose of objects when they are no longer being used and make them available for garbage collection. Per ulteriori informazioni, vedere la gestione della durata.For more information, see Lifetime Management.

Per creare l'adattatore sul lato hostTo create the host-side adapter

  1. Aggiungere un nuovo progetto denominato Calc1HostSideAdapter per il CalculatorV1 soluzione.Add a new project named Calc1HostSideAdapter to the CalculatorV1 solution. Come base il libreria di classi modello.Base it on the Class Library template.

  2. In Esplora, aggiungere riferimenti agli assembly riportati di seguito per il Calc1HostSideAdapter progetto:In Solution Explorer, add references to the following assemblies to the Calc1HostSideAdapter project:

    System.AddIn.dllSystem.AddIn.dll

    System.AddIn.Contract.dllSystem.AddIn.Contract.dll

  3. Aggiungere riferimenti ai progetti per i segmenti adiacenti:Add project references to the projects for the adjacent segments:

    Calc1Contract

    Calc1HVA

  4. Selezionare ogni riferimento a progetto e in proprietà impostare Copia localmente a False.Select each project reference, and in Properties set Copy Local to False. In Visual Basic, usare il riferimenti scheda della le proprietà del progetto impostare Copia localmente per False per i due riferimenti al progetto.In Visual Basic, use the References tab of Project Properties to set Copy Local to False for the two project references.

  5. Rinominare la classe del progetto predefinita CalculatorContractToViewHostSideAdapter.Rename the project's default class CalculatorContractToViewHostSideAdapter.

  6. Nel file di classe, aggiungere riferimenti a spazi dei nomi per System.AddIn.Pipeline.In the class file, add namespace references to System.AddIn.Pipeline.

  7. Nel file di classe, aggiungere riferimenti a spazi dei nomi per i segmenti adiacenti: CalcHVAs e CalculatorContracts.In the class file, add namespace references for the adjacent segments: CalcHVAs and CalculatorContracts. (In Visual Basic, questi riferimenti dello spazio dei nomi sono Calc1HVA.CalcHVAs e Calc1Contract.CalculatorContracts, a meno che non è stato disattivato gli spazi dei nomi predefinito nei progetti di Visual Basic.)(In Visual Basic, these namespace references are Calc1HVA.CalcHVAs and Calc1Contract.CalculatorContracts, unless you have turned off the default namespaces in your Visual Basic projects.)

  8. Applicare il HostAdapterAttribute attributo il CalculatorContractToViewHostSideAdapter (classe), per facilitarne l'identificazione del segmento di adattatore sul lato host.Apply the HostAdapterAttribute attribute to the CalculatorContractToViewHostSideAdapter class, to identify it as the host-side adapter segment.

  9. Rendere il CalculatorContractToViewHostSideAdapter classe implementa l'interfaccia che rappresenta la visualizzazione host del componente aggiuntivo: Calc1HVAs.ICalculator (Calc1HVA.CalcHVAs.ICalculator in Visual Basic).Make the CalculatorContractToViewHostSideAdapter class implement the interface that represents the host view of the add-in: Calc1HVAs.ICalculator (Calc1HVA.CalcHVAs.ICalculator in Visual Basic).

  10. Aggiungere un costruttore pubblico che accetta il tipo di contratto della pipeline, ICalc1Contract.Add a public constructor that accepts the pipeline contract type, ICalc1Contract. Il costruttore deve memorizzare nella cache il riferimento al contratto.The constructor must cache the reference to the contract. Inoltre necessario creare e memorizzare nella cache un nuovo ContractHandle per il contratto, per gestire la durata del componente aggiuntivo.It must also create and cache a new ContractHandle for the contract, to manage the lifetime of the add-in.

    Importante

    Il ContractHandle è fondamentale per la gestione della durata.The ContractHandle is critical to lifetime management. Se non si riesce a mantenere un riferimento per il ContractHandle dell'oggetto, quest ' ultimo verrà recuperato dalla procedura di garbage collection e la pipeline verrà interrotta quando il programma non previsto.If you fail to keep a reference to the ContractHandle object, garbage collection will reclaim it, and the pipeline will shut down when your program does not expect it. Questo può causare errori difficili da diagnosticare, ad esempio AppDomainUnloadedException.This can lead to errors that are difficult to diagnose, such as AppDomainUnloadedException. L'arresto è una fase normale il ciclo di vita di una pipeline, in modo non è possibile per il codice di gestione del ciclo di vita rilevare che questa condizione è un errore.Shutdown is a normal stage in the life of a pipeline, so there is no way for the lifetime management code to detect that this condition is an error.

  11. Per implementare i membri di ICalculator, è sufficiente chiamare i membri corrispondenti del ICalc1Contract istanza che viene passato al costruttore e restituisce i risultati.To implement the members of ICalculator, simply call the corresponding members of the ICalc1Contract instance that is passed to the constructor, and return the results. In questo modo il contratto (ICalc1Contract) per la visualizzazione (ICalculator).This adapts the contract (ICalc1Contract) to the view (ICalculator).

    Il codice seguente illustra l'adattatore sul lato host completato.The following code shows the completed host-side adapter.

    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);
            }
        }
    }
    
    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
    
  12. Facoltativamente, compilare la soluzione di Visual Studio.Optionally, build the Visual Studio solution.

La creazione dell'HostCreating the Host

Un'applicazione host interagisce con il componente aggiuntivo tramite la visualizzazione host del componente aggiuntivo.A host application interacts with the add-in through the host view of the add-in. Utilizza i metodi di individuazione e attivazione del componente aggiuntivo forniti dal AddInStore e AddInToken classi per eseguire le operazioni seguenti:It uses add-in discovery and activation methods provided by the AddInStore and AddInToken classes to do the following:

  • Aggiornare la cache di informazioni sulla pipeline e componente aggiuntivo.Update the cache of pipeline and add-in information.

  • Trovare i componenti aggiuntivi del tipo di visualizzazione host, ICalculator, nella directory radice della pipeline specificata.Find add-ins of the host view type, ICalculator, under the specified pipeline root directory.

  • Richiedere all'utente di specificare il componente aggiuntivo da utilizzare.Prompt the user to specify which add-in to use.

  • Attivare il componente aggiuntivo selezionato in un nuovo dominio applicazione con un livello di attendibilità di sicurezza specificato.Activate the selected add-in in a new application domain with a specified security trust level.

  • Eseguire personalizzata RunCalculator metodo, che chiama i metodi del componente aggiuntivo come specificato dalla visualizzazione host del componente aggiuntivo.Run the custom RunCalculator method, which calls the add-in's methods as specified by the host view of the add-in.

Per creare l'hostTo create the host

  1. Aggiungere un nuovo progetto denominato Calc1Host per il CalculatorV1 soluzione.Add a new project named Calc1Host to the CalculatorV1 solution. Come base il applicazione Console modello.Base it on the Console Application template.

  2. In Esplora, aggiungere un riferimento all'assembly System.AddIn.dll per il Calc1Host progetto.In Solution Explorer, add a reference to the System.AddIn.dll assembly to the Calc1Host project.

  3. Aggiungere un riferimento al progetto il Calc1HVA progetto.Add a project reference to the Calc1HVA project. Selezionare il riferimento al progetto e in proprietà impostare Copia localmente a False.Select the project reference, and in Properties set Copy Local to False. In Visual Basic, usare il riferimenti scheda le proprietà del progetto per impostare Copia localmente per False.In Visual Basic, use the References tab of Project Properties to set Copy Local to False.

  4. Rinominare il file di classe (modulo di Visual Basic) MathHost1.Rename the class file (module in Visual Basic) MathHost1.

  5. In Visual Basic, usare il applicazione scheda della finestra di le proprietà del progetto la finestra di dialogo per impostare oggetto di avvio per Sub Main.In Visual Basic, use the Application tab of the Project Properties dialog box to set Startup object to Sub Main.

  6. Nel file di classe o modulo, aggiungere un riferimento dello spazio dei nomi a System.AddIn.Hosting.In the class or module file, add a namespace reference to System.AddIn.Hosting.

  7. Nel file di classe o modulo, aggiungere un riferimento dello spazio dei nomi per la visualizzazione host del componente aggiuntivo: CalcHVAs.In the class or module file, add a namespace reference for the host view of the add-in: CalcHVAs. (In Visual Basic, questo spazio dei nomi riferimento è Calc1HVA.CalcHVAs, a meno che non è stato disattivato gli spazi dei nomi predefinito nei progetti di Visual Basic.)(In Visual Basic, this namespace reference is Calc1HVA.CalcHVAs, unless you have turned off the default namespaces in your Visual Basic projects.)

  8. In Esplora, selezionare la soluzione e dal progetto dal menu proprietà.In Solution Explorer, select the solution and from the Project menu choose Properties. Nel pagine proprietà soluzione la finestra di dialogo, impostare il progetto di avvio singolo da questo progetto di applicazione host.In the Solution Property Pages dialog box, set the Single Startup Project to be this host application project.

  9. Nel file di classe o modulo, usare il AddInStore.Update metodo per aggiornare la cache.In the class or module file, use the AddInStore.Update method to update the cache. Utilizzare il AddInStore.FindAddIn metodo per ottenere una raccolta di token, utilizzare il AddInToken.Activate metodo per attivare un componente aggiuntivo.Use the AddInStore.FindAddIn method to get a collection of tokens, and use the AddInToken.Activate method to activate an add-in.

    Il codice seguente illustra l'applicazione host completata.The following code shows the completed host application.

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

    Nota

    Questo codice si presuppone che la struttura di cartelle della pipeline si trova nella cartella dell'applicazione.This code assumes that the pipeline folder structure is located in the application folder. Se si trova in un' posizione, modificare la riga di codice che imposta il addInRoot variabile, in modo che la variabile contiene il percorso per la struttura di directory della pipeline.If you located it elsewhere, change the line of code that sets the addInRoot variable, so that the variable contains the path to your pipeline directory structure.

    Il codice Usa un ChooseCalculator metodo per elencare i token e richiedere all'utente di scegliere un componente aggiuntivo.The code uses a ChooseCalculator method to list the tokens and to prompt the user to choose an add-in. Il RunCalculator metodo richiede l'immissione di espressioni semplici operazioni matematiche, analizza le espressioni utilizzando la Parser classe e consente di visualizzare i risultati restituiti dal componente aggiuntivo.The RunCalculator method prompts the user for simple math expressions, parses the expressions using the Parser class, and displays the results returned by the add-in.

  10. Facoltativamente, compilare la soluzione di Visual Studio.Optionally, build the Visual Studio solution.

Creare il componente aggiuntivoCreating the Add-In

Un componente aggiuntivo implementa i metodi specificati da parte della vista del componente aggiuntivo.An add-in implements the methods specified by the add-in view. Questo componente aggiuntivo implementa il Add, Subtract, Multiply, e Divide operazioni e restituisce i risultati all'host.This add-in implements the Add, Subtract, Multiply, and Divide operations and returns the results to the host.

Per creare il componente aggiuntivoTo create the add-in

  1. Aggiungere un nuovo progetto denominato AddInCalcV1 per il CalculatorV1 soluzione.Add a new project named AddInCalcV1 to the CalculatorV1 solution. Come base il libreria di classi modello.Base it on the Class Library template.

  2. In Esplora, aggiungere un riferimento all'assembly System.AddIn.dll al progetto.In Solution Explorer, add a reference to the System.AddIn.dll assembly to the project.

  3. Aggiungere un riferimento al progetto il Calc1AddInView progetto.Add a project reference to the Calc1AddInView project. Selezionare il riferimento al progetto e in proprietà, impostare Copia localmente a False.Select the project reference, and in Properties, set Copy Local to False. In Visual Basic, usare il riferimenti scheda le proprietà del progetto per impostare Copia localmente per False per il riferimento al progetto.In Visual Basic, use the References tab of Project Properties to set Copy Local to False for the project reference.

  4. Rinominare la classe AddInCalcV1.Rename the class AddInCalcV1.

  5. Nel file di classe, aggiungere un riferimento dello spazio dei nomi a System.AddIn e il segmento di visualizzazione: CalcAddInViews (Calc1AddInView.CalcAddInViews in Visual Basic).In the class file, add a namespace reference to System.AddIn and the add-in view segment: CalcAddInViews (Calc1AddInView.CalcAddInViews in Visual Basic).

  6. Applicare il AddInAttribute attributo il AddInCalcV1 (classe), per identificare la classe come un componente aggiuntivo.Apply the AddInAttribute attribute to the AddInCalcV1 class, to identify the class as an add-in.

  7. Rendere il AddInCalcV1 classe implementa l'interfaccia che rappresenta la vista del componente aggiuntivo: CalcAddInViews.ICalculator (Calc1AddInView.CalcAddInViews.ICalculator in Visual Basic).Make the AddInCalcV1 class implement the interface that represents the add-in view: CalcAddInViews.ICalculator (Calc1AddInView.CalcAddInViews.ICalculator in Visual Basic).

  8. Implementare i membri di ICalculator restituendo i risultati dei calcoli appropriati.Implement the members of ICalculator by returning the results of the appropriate calculations.

    Il codice seguente viene illustrato il componente aggiuntivo completato.The following code shows the completed add-in.

    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;
            }
        }
    }
    
    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
    
  9. Facoltativamente, compilare la soluzione di Visual Studio.Optionally, build the Visual Studio solution.

Distribuzione della PipelineDeploying the Pipeline

A questo punto si è pronti compilare e distribuire i segmenti del componente aggiuntivo per la struttura di directory della pipeline richiesta.You are now ready to build and deploy the add-in segments to the required pipeline directory structure.

Per distribuire i segmenti della pipelineTo deploy the segments to the pipeline

  1. Per ogni progetto nella soluzione, utilizzare il compilare scheda della le proprietà del progetto (il compilare scheda in Visual Basic) per impostare il valore della percorso di Output (il il percorso di output di compilazione in Visual Basic).For each project in the solution, use the Build tab of Project Properties (the Compile tab in Visual Basic) to set the value of the Output path (the Build output path in Visual Basic). Se la cartella dell'applicazione denominata MyApp, ad esempio, i progetti saranno compilati nelle cartelle seguenti:If you named your application folder MyApp, for example, your projects would build into the following folders:

    ProgettoProject PathPath
    AddInCalcV1AddInCalcV1 MyApp\Pipeline\AddIns\CalcV1MyApp\Pipeline\AddIns\CalcV1
    Calc1AddInSideAdapterCalc1AddInSideAdapter MyApp\Pipeline\AddInSideAdaptersMyApp\Pipeline\AddInSideAdapters
    Calc1AddInViewCalc1AddInView MyApp\Pipeline\AddInViewsMyApp\Pipeline\AddInViews
    Calc1ContractCalc1Contract MyApp\Pipeline\ContractsMyApp\Pipeline\Contracts
    Calc1HostCalc1Host MyAppMyApp
    Calc1HostSideAdapterCalc1HostSideAdapter MyApp\Pipeline\HostSideAdaptersMyApp\Pipeline\HostSideAdapters
    Calc1HVACalc1HVA MyAppMyApp

    Nota

    Se si è deciso di inserire la struttura di cartelle della pipeline in un percorso diverso dalla cartella dell'applicazione, è necessario modificare di conseguenza i percorsi mostrati nella tabella.If you decided to put your pipeline folder structure in a location other than your application folder, you must modify the paths shown in the table accordingly. Vedere la sezione requisiti della pipeline directory requisiti di sviluppo Pipeline.See the discussion of pipeline directory requirements in Pipeline Development Requirements.

  2. Compilare la soluzione di Visual Studio.Build the Visual Studio solution.

  3. Controllare le directory della pipeline e di applicazione per assicurarsi che gli assembly sono stati copiati nelle directory corrette e che nessun copie aggiuntive di assembly siano state installate nelle cartelle errate.Check the application and pipeline directories to ensure that the assemblies were copied to the correct directories and that no extra copies of assemblies were installed in the wrong folders.

    Nota

    Se non è stato modificato Copia localmente a False per il Calc1AddInView riferimento nel progetto di AddInCalcV1 progetto, problemi relativi al contesto del caricatore impedirà il componente aggiuntivo si trovano.If you did not change Copy Local to False for the Calc1AddInView project reference in the AddInCalcV1 project, loader context problems will prevent the add-in from being located.

    Per informazioni su come distribuire la pipeline, vedere requisiti di sviluppo Pipeline.For information about deploying to the pipeline, see Pipeline Development Requirements.

Esecuzione dell'applicazione HostRunning the Host Application

A questo punto si è pronti eseguire l'host e interagire con il componente aggiuntivo.You are now ready to run the host and interact with the add-in.

Per eseguire l'applicazione hostTo run the host application

  1. Al prompt dei comandi, passare alla directory dell'applicazione ed eseguire l'applicazione host, Calc1Host.exe.At the command prompt, go to the application directory and run the host application, Calc1Host.exe.

  2. L'host consente di individuare tutti i componenti aggiuntivi disponibili del tipo e viene richiesto di selezionare un componente aggiuntivo.The host finds all available add-ins of its type and prompts you to select an add-in. Immettere 1 per il componente aggiuntivo è disponibile solo.Enter 1 for the only available add-in.

  3. Immettere un'equazione per il calcolo, ad esempio 2 + 2.Enter an equation for the calculator, such as 2 + 2. Devono essere presenti spazi tra i numeri e l'operatore.There must be spaces between the numbers and the operator.

  4. Tipo uscire e premere il invio tasto per chiudere l'applicazione.Type exit and press the Enter key to close the application.

Vedere ancheSee Also

Procedura dettagliata: Abilitazione della compatibilità con le versioni precedenti in base alle modifiche dell'HostWalkthrough: Enabling Backward Compatibility as Your Host Changes
Procedura dettagliata: Passaggio di raccolte tra componenti aggiuntivi e hostWalkthrough: Passing Collections Between Hosts and Add-Ins
Requisiti di sviluppo pipelinePipeline Development Requirements
Contratti, viste e le schedeContracts, Views, and Adapters
Sviluppo pipelinePipeline Development