Procédure pas à pas : création d'une application extensible
Cette procédure pas à pas décrit comment créer un pipeline pour un complément qui exécute des fonctions de calculatrice simples. Elle ne fournit pas de scénario réel ; au lieu de cela, elle présente les fonctionnalités de base d'un pipeline et indique comment un complément peut fournir des services pour un hôte.
Cette procédure pas à pas décrit les tâches suivantes :
Création d'une solution Visual Studio.
Création de la structure de répertoires du pipeline.
Création du contrat et des vues.
Création de l'adaptateur côté complément.
Création de l'adaptateur côté hôte.
Création de l'hôte.
Création du complément.
Déploiement du pipeline.
Exécution de l'application hôte.
Ce pipeline passe uniquement des types sérialisables (Double et String) entre l'hôte et le complément. Pour obtenir un exemple indiquant comment passer des collections de types de données complexes, consultez Procédure pas à pas : passage de collections entre des hôtes et des compléments.
Le contrat pour ce pipeline définit un modèle objet de quatre opérations arithmétiques : addition, soustraction, multiplication et division. L'hôte fournit au complément une équation à calculer, par exemple 2 + 2, et le complément retourne le résultat à l'hôte.
La version 2 du complément de calculatrice fournit davantage de possibilités de calcul et présente le versioning. Sa description figure dans Procédure pas à pas : activation de la compatibilité descendante lorsque votre hôte change.
![]() |
---|
Vous trouverez des exemples de code supplémentaires, ainsi que des présentations technologiques destinées aux clients des outils de génération de pipelines de compléments, sur le site Managed Extensibility and Add-In Framework (en anglais) de CodePlex. |
Composants requis
Les éléments suivants sont nécessaires pour effectuer cette procédure pas à pas :
- Visual Studio.
Création d'une solution Visual Studio
Utilisez une solution dans Visual Studio pour contenir les projets de vos segments de pipeline.
Pour créer la solution de pipeline
Dans Visual Studio, créez un nouveau projet nommé Calc1Contract. Basez-le sur le modèle Bibliothèque de classes.
Nommez la solution CalculatorV1.
Création de la structure de répertoires du pipeline
Le modèle de complément requiert que les assemblys du segment de pipeline soient placés dans une structure de répertoires spécifiée. Pour plus d'informations sur la structure du pipeline, consultez Spécifications du développement de pipelines.
Pour créer la structure de répertoires du pipeline
Créez un dossier d'application à un emplacement quelconque sur votre ordinateur.
Dans ce dossier, créez la structure suivante :
Pipeline AddIns CalcV1 CalcV2 AddInSideAdapters AddInViews Contracts HostSideAdapters
Il n'est pas nécessaire de placer la structure des dossiers de pipeline dans votre dossier d'application ; ceci est effectué ici uniquement pour des raisons de commodité. À l'étape appropriée, la procédure pas à pas explique comment modifier le code si la structure des dossiers de pipeline est à un emplacement différent. Consultez la description des spécifications de répertoires du pipeline dans Spécifications du développement de pipelines.
Remarque
Le dossier CalcV2 n'est pas utilisé dans cette procédure pas à pas ; c'est un espace réservé pour Procédure pas à pas : activation de la compatibilité descendante lorsque votre hôte change.
Création du contrat et des vues
Le segment de contrat pour ce pipeline définit l'interface ICalc1Contract, qui définit quatre méthodes : add, subtract, multiply et divide.
Pour créer le contrat
Dans la solution Visual Studio nommée CalculatorV1, ouvrez le projet Calc1Contract.
Dans l'Explorateur de solutions, ajoutez au projet Calc1Contract des références aux assemblys suivants :
System.AddIn.Contract.dll
System.AddIn.dll
Dans l'Explorateur de solutions, excluez la classe par défaut ajoutée aux nouveaux projets Bibliothèque de classes.
Dans l'Explorateur de solutions, ajoutez un nouvel élément au projet, à l'aide du modèle Interface. Dans la boîte de dialogue Ajouter un nouvel élément, nommez l'interface ICalc1Contract.
Dans le fichier d'interface, ajoutez des références d'espace de noms à System.AddIn.Contract et System.AddIn.Pipeline.
Utilisez le code suivant pour compléter ce segment de contrat. Notez que cette interface doit avoir l'attribut AddInContractAttribute.
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); } }
Générez éventuellement la solution Visual Studio. La solution ne peut pas être exécutée avant la dernière procédure, mais la générer après chaque procédure garantit que chaque projet est correct.
Étant donné que la vue de complément et la vue hôte du complément ont généralement le même code, en particulier dans la première version d'un complément, vous pouvez facilement créer ces vues en même temps. Elles diffèrent par un seul facteur : la vue de complément requiert l'attribut AddInBaseAttribute, tandis que la vue hôte du complément ne requiert aucun attribut.
Pour créer la vue de complément
Ajoutez un nouveau projet nommé Calc1AddInView à la solution CalculatorV1. Basez-le sur le modèle Bibliothèque de classes.
Dans l'Explorateur de solutions, ajoutez au projet Calc1AddInView une référence à System.AddIn.dll.
Dans l'Explorateur de solutions, excluez la classe par défaut ajoutée aux nouveaux projets Bibliothèque de classes et ajoutez un nouvel élément au projet, à l'aide du modèle Interface. Dans la boîte de dialogue Ajouter un nouvel élément, nommez l'interface ICalculator.
Dans le fichier d'interface, ajoutez une référence d'espace de noms à System.AddIn.Pipeline.
Utilisez le code suivant pour terminer cette vue de complément. Notez que cette interface doit avoir l'attribut AddInBaseAttribute.
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); } }
Générez éventuellement la solution Visual Studio.
Pour créer la vue hôte du complément
Ajoutez un nouveau projet nommé Calc1HVA à la solution CalculatorV1. Basez-le sur le modèle Bibliothèque de classes.
Dans l'Explorateur de solutions, excluez la classe par défaut ajoutée aux nouveaux projets Bibliothèque de classes et ajoutez un nouvel élément au projet, à l'aide du modèle Interface. Dans la boîte de dialogue Ajouter un nouvel élément, nommez l'interface ICalculator.
Dans le fichier d'interface, utilisez le code suivant pour terminer la vue hôte du complément.
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); } }
Générez éventuellement la solution Visual Studio.
Création de l'adaptateur côté complément
Cet adaptateur côté complément se compose d'un adaptateur de vue en contrat. Ce segment de pipeline convertit les types de la vue de complément en contrat.
Dans ce pipeline, le complément fournit un service à l'hôte et les types circulent du complément vers l'hôte. Étant donné qu'aucun type ne circule de l'hôte vers le complément, vous n'avez pas à inclure un adaptateur de contrat en vue sur le côté complément de ce pipeline.
Pour créer l'adaptateur côté complément
Ajoutez un nouveau projet nommé Calc1AddInSideAdapter à la solution CalculatorV1. Basez-le sur le modèle Bibliothèque de classes.
Dans l'Explorateur de solutions, ajoutez au projet Calc1AddInSideAdapter des références aux assemblys suivants :
System.AddIn.dll
System.AddIn.Contract.dll
Ajoutez des références de projet aux projets pour les segments de pipeline adjacents :
Calc1AddInView
Calc1Contract
Sélectionnez chaque référence de projet, puis dans Propriétés, affectez à Copie locale la valeur False. En Visual Basic, utilisez l'onglet Références de Propriétés du projet pour affecter à Copie locale la valeur False pour les deux références de projet.
Renommez la classe par défaut du projet CalculatorViewToContractAddInSideAdapter.
Dans le fichier de classe, ajoutez des références d'espace de noms à System.AddIn.Pipeline.
Dans le fichier de classe, ajoutez des références d'espace de noms aux segments adjacents : CalcAddInViews et CalculatorContracts. (En Visual Basic, ces références d'espace de noms sont Calc1AddInView.CalcAddInViews et Calc1Contract.CalculatorContracts, à moins que vous ayez désactivé les espaces de noms par défaut dans vos projets Visual Basic.)
Appliquez l'attribut AddInAdapterAttribute à la classe CalculatorViewToContractAddInSideAdapter, pour l'identifier comme adaptateur côté complément.
Définissez la classe CalculatorViewToContractAddInSideAdapter pour qu'elle hérite de ContractBase, qui fournit une implémentation par défaut de l'interface IContract et implémente l'interface de contrat pour le pipeline, ICalc1Contract.
Ajoutez un constructeur public qui accepte un ICalculator, le met en cache dans un champ privé et appelle le constructeur de classe de base.
Pour implémenter les membres de ICalc1Contract, appelez simplement les membres correspondants de l'instance ICalculator qui est passée au constructeur, et retournez les résultats. Ceci adapte la vue (ICalculator) au contrat (ICalc1Contract).
Le code suivant affiche l'adaptateur côté complément terminé.
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); } } }
Générez éventuellement la solution Visual Studio.
Création de l'adaptateur côté hôte
Cet adaptateur côté hôte se compose d'un adaptateur de contrat en vue. Ce segment adapte le contrat à la vue hôte du complément.
Dans ce pipeline, le complément fournit un service à l'hôte et les types circulent du complément vers l'hôte. Étant donné qu'aucun type ne circule de l'hôte vers le complément, vous n'avez pas à inclure un adaptateur de vue en contrat.
Pour implémenter la gestion de la durée de vie, utilisez un objet ContractHandle pour attacher un jeton de durée de vie au contrat. Vous devez conserver une référence à ce handle afin que la gestion de la durée de vie fonctionne. Une fois que le jeton est appliqué, aucune programmation supplémentaire n'est nécessaire, car le système de complément peut supprimer les objets lorsqu'ils ne sont plus utilisés et les rendre disponibles pour le garbage collection. Pour plus d'informations, consultez Gestion de la durée de vie.
Pour créer l'adaptateur côté hôte
Ajoutez un nouveau projet nommé Calc1HostSideAdapter à la solution CalculatorV1. Basez-le sur le modèle Bibliothèque de classes.
Dans l'Explorateur de solutions, ajoutez au projet Calc1HostSideAdapter des références aux assemblys suivants :
System.AddIn.dll
System.AddIn.Contract.dll
Ajoutez des références de projet aux projets pour les segments adjacents :
Calc1Contract
Calc1HVA
Sélectionnez chaque référence de projet, puis dans Propriétés, affectez à Copie locale la valeur False. En Visual Basic, utilisez l'onglet Références de Propriétés du projet pour affecter à Copie locale la valeur False pour les deux références de projet.
Renommez la classe par défaut du projet CalculatorContractToViewHostSideAdapter.
Dans le fichier de classe, ajoutez des références d'espace de noms à System.AddIn.Pipeline.
Dans le fichier de classe, ajoutez des références d'espace de noms aux segments adjacents : CalcHVAs et CalculatorContracts. (En Visual Basic, ces références d'espace de noms sont Calc1HVA.CalcHVAs et Calc1Contract.CalculatorContracts, à moins que vous ayez désactivé les espaces de noms par défaut dans vos projets Visual Basic.)
Appliquez l'attribut HostAdapterAttribute à la classe CalculatorContractToViewHostSideAdapter, pour l'identifier comme segment d'adaptateur côté hôte.
Définissez la classe CalculatorContractToViewHostSideAdapter pour qu'elle implémente l'interface qui représente la vue hôte du complément : Calc1HVAs.ICalculator (Calc1HVA.CalcHVAs.ICalculator en Visual Basic).
Ajoutez un constructeur public qui accepte le type du contrat du pipeline, ICalc1Contract. Le constructeur doit mettre en cache la référence au contrat. Il doit également créer et mettre en cache un nouveau ContractHandle pour le contrat, pour gérer la durée de vie du complément.
Important
ContractHandle est critique pour la gestion de la durée de vie.Si vous ne parvenez pas à conserver une référence à l'objet ContractHandle, le garbage collection la récupérera, et le pipeline s'arrêtera quand le programme ne s'y attend pas.Cela peut provoquer des erreurs difficiles à diagnostiquer, telles que AppDomainUnloadedException.L'arrêt est une étape normale dans la vie d'un pipeline ; il est donc impossible pour le code de gestion de la durée de vie de détecter que cette condition est une erreur.
Pour implémenter les membres de ICalculator, appelez simplement les membres correspondants de l'instance ICalc1Contract qui est passée au constructeur, et retournez les résultats. Ceci adapte le contrat (ICalc1Contract) à la vue (ICalculator).
Le code suivant affiche l'adaptateur côté hôte terminé.
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); } } }
Générez éventuellement la solution Visual Studio.
Création de l'hôte
Une application hôte interagit avec le complément via la vue hôte du complément. Elle utilise les méthodes d'activation et de découverte de complément fournies par les classes AddInStore et AddInToken pour effectuer les opérations suivantes :
Mettre à jour le cache du pipeline et les informations de complément.
Rechercher des compléments du type de vue hôte, ICalculator sous le répertoire racine du pipeline spécifié.
Inviter l'utilisateur à spécifier le complément à utiliser.
Activer le complément sélectionné dans un nouveau domaine d'application avec un niveau de confiance de sécurité spécifié.
Exécuter la méthode RunCalculator personnalisée, qui appelle les méthodes du complément comme indiqué par la vue hôte du complément.
Pour créer l'hôte
Ajoutez un nouveau projet nommé Calc1Host à la solution CalculatorV1. Basez-le sur le modèle Application console.
Dans l'Explorateur de solutions, ajoutez au projet Calc1Host une référence à l'assembly System.AddIn.dll.
Ajoutez une référence de projet au projet Calc1HVA. Sélectionnez la référence de projet, puis dans Propriétés, affectez à Copie locale la valeur False. En Visual Basic, utilisez l'onglet Références de Propriétés du projet pour affecter à Copie locale la valeur False.
Renommez le fichier de classe (module en Visual Basic) MathHost1.
En Visual Basic, utilisez l'onglet Application de la boîte de dialogue Propriétés du projet pour affecter à Objet de démarrage la valeur Sub Main.
Dans le fichier de classe ou de module, ajoutez une référence d'espace de noms à System.AddIn.Hosting.
Dans le fichier de classe ou de module, ajoutez une référence d'espace de noms pour la vue hôte du complément : CalcHVAs. (En Visual Basic, cette référence d'espace de noms est Calc1HVA.CalcHVAs, à moins que vous ayez désactivé les espaces de noms par défaut dans vos projets Visual Basic.)
Dans l'Explorateur de solutions, sélectionnez la solution puis, dans le menu Projet, sélectionnez Propriétés. Dans la boîte de dialogue Pages de propriétés de Solution, définissez le Projet de démarrage unique comme projet d'application hôte.
Dans le fichier de classe ou de module, utilisez la méthode AddInStore.Update pour mettre à jour le cache. Utilisez la méthode AddInStore.FindAddIn pour obtenir une collection de jetons et utilisez la méthode AddInToken.Activate pour activer un complément.
Le code suivant montre l'application hôte terminée.
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; } } } }
Remarque
Ce code suppose que la structure des dossiers de pipeline est localisée dans le dossier d'application.Si vous l'avez localisé ailleurs, modifiez la ligne de code qui définit la variable addInRoot, afin que cette variable contienne le chemin d'accès à votre structure de répertoires du pipeline.
Le code utilise une méthode ChooseCalculator pour répertorier les jetons et inviter l'utilisateur à choisir un complément. La méthode RunCalculator invite l'utilisateur à entrer des expressions mathématiques simples, analyse les expressions à l'aide de la classe Parser et affiche les résultats retournés par le complément.
Générez éventuellement la solution Visual Studio.
Création du complément
Un complément implémente les méthodes spécifiées par la vue de complément. Ce complément implémente les opérations Add, Subtract, Multiply et Divide et retourne les résultats à l'hôte.
Pour créer le complément
Ajoutez un nouveau projet nommé AddInCalcV1 à la solution CalculatorV1. Basez-le sur le modèle Bibliothèque de classes.
Dans l'Explorateur de solutions, ajoutez au projet une référence à l'assembly System.AddIn.dll.
Ajoutez une référence de projet au projet Calc1AddInView. Sélectionnez la référence de projet, puis dans Propriétés, affectez à Copie locale la valeur False. En Visual Basic, utilisez l'onglet Références de Propriétés du projet pour affecter à Copie locale la valeur False pour la référence de projet.
Renommez la classe AddInCalcV1.
Dans le fichier de classe, ajoutez une référence d'espace de noms à System.AddIn et le segment de vue de complément : CalcAddInViews (Calc1AddInView.CalcAddInViews en Visual Basic).
Appliquez l'attribut AddInAttribute à la classe AddInCalcV1, pour identifier la classe comme un complément.
Définissez la classe AddInCalcV1 pour qu'elle implémente l'interface qui représente la vue de complément : CalcAddInViews.ICalculator (Calc1AddInView.CalcAddInViews.ICalculator en Visual Basic).
Implémentez les membres de ICalculator en retournant les résultats des calculs appropriés.
Le code suivant montre le complément terminé.
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; } } }
Générez éventuellement la solution Visual Studio.
Déploiement du pipeline
Vous êtes maintenant prêt à générer et déployer les segments de complément vers la structure de répertoires du pipeline requise.
Pour déployer les segments vers le pipeline
Pour chaque projet dans la solution, utilisez l'onglet Génération de Propriétés du projet (onglet Compiler en Visual Basic) pour définir la valeur du Chemin de sortie (Chemin de sortie de la génération en Visual Basic). Si vous avez nommé votre dossier d'application MyApp, par exemple, vos projets seraient générés dans les dossiers suivants :
Projet
Chemin d'accès
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
Remarque
Si vous avez décidé de placer votre structure des dossiers de pipeline dans un emplacement autre que votre dossier d'application, vous devez modifier les chemins d'accès affichés dans ce tableau en conséquence.Consultez la description des spécifications de répertoires du pipeline dans Spécifications du développement de pipelines.
Générez la solution Visual Studio.
Vérifiez les répertoires de l'application et du pipeline pour vous assurer que les assemblys ont été copiés dans les répertoires corrects et qu'aucune copie supplémentaire des assemblys n'a été installée dans des dossiers incorrects.
Remarque
Si vous n'avez pas changé Copie locale en False pour la référence de projet Calc1AddInView dans le projet AddInCalcV1, les problèmes du contexte du chargeur empêcheront la localisation du complément.
Pour plus d'informations sur le déploiement vers le pipeline, consultez Spécifications du développement de pipelines.
Exécution de l'application hôte
Vous êtes maintenant prêt à exécuter l'hôte et à interagir avec le complément.
Pour exécuter l'application hôte
À l'invite de commandes, accédez au répertoire de l'application et exécutez l'application hôte, Calc1Host.exe.
L'hôte recherche tous les compléments disponibles de son type et vous invite à sélectionner un complément. Entrez 1 pour le seul complément disponible.
Entrez une équation pour la calculatrice, telle que 2 + 2. Les nombres et l'opérateur doivent être séparés par un espace.
Tapez quitter, puis appuyez sur la touche Entrée pour fermer l'application.
Voir aussi
Tâches
Procédure pas à pas : activation de la compatibilité descendante lorsque votre hôte change
Procédure pas à pas : passage de collections entre des hôtes et des compléments