Procédure pas à pas : Création d’un complément de code managé pour vérifier la compatibilité PWA (traduction automatique)

Dernière modification : vendredi 30 avril 2010

S’applique à : Office 2010 | Project 2010 | Project Server 2010 | SharePoint Server 2010

Dans cet article
Création du complément
Débogage du complément
Déploiement du complément

Cet article montre comment développer et déployer du code managé pour Microsoft Project Professionnel 2010 à l’aide de Outils de développement Microsoft Office dans Microsoft Visual Studio 2010. Le complément vérifie pour le projet les conditions qui peuvent l’empêcher d’être édité dans Project Web App. (Cet article est une adaptation d’un contenu et d’un exemple de code conçu par Mike Shughrue, Microsoft Corporation.)

Visual Studio 2010 contient des modèles de projet de compléments Microsoft Office qui le rendent plus facile à écrire, déboguer et déployer des compléments de code managé. Les compléments sont utiles pour étendre et d'automatiser les fonctionnalités de projet. Dans la mesure où les compléments sont écrits en Microsoft Visual c#, Microsoft Visual Basic ou tout autre langage géré, la syntaxe est déjà familière aux programmeurs qui utilisent Microsoft.NET Framework et fournit un accès complet à la.NET Framework. Vous pouvez déboguer une macro complémentaire dans l'environnement de développement interactif Visual Studio (IDE) de la même façon que vous déboguez d'autres types d'applications. Déploiement de compléments COM était auparavant un défi, mais Visual Studio 2010 facilite le déploiement à l'aide de ClickOnce.

Le complément utilise le modèle d'objet de projet client pour accéder aux données de projet et exécute une série de vérifications pour déterminer si le projet est modifiable dans Project Web App. Si le projet ne répond pas aux critères, la macro complémentaire affiche une boîte de dialogue avec une liste de conditions qui rendent le projet en lecture seule dans Project Web App. Le complément automatiquement à l'aide d'un gestionnaire d'événements ProjectBeforeSave2 et peut également être exécuté interactivement à l'aide d'un bouton de ruban personnalisé.

Scénario :   Dans Project Server 2010, les projets sont modifiables dans la page Centre de projets de Project Web App. En raison de contraintes de moteur planification côté serveur, les conditions suivantes rendent un projet en lecture seule dans Project Web App :

• Le projet est un projet principal.

• Le projet contient une ou plusieurs tâches null. Une tâche null est une ligne de tâche vide entre deux autres tâches.

• Une tâche est un type de travail fixe. Par défaut, les tâches planifiées automatiquement sont la capacité fixe. Tâches peuvent également être définies à durée fixe.

• Une tâche a un calendrier de tâches qui, dans le client de projet peut être spécifié en plus du calendrier de projet et les calendriers de ressources. Par défaut, un calendrier des tâches est « None ».

Bien que les conditions précédentes sont acceptables dans Project Professionnel 2010, responsable de projet doit être averti qu'un projet ne soient pas modifiable dans Project Web App avant d'enregistrer le projet. La meilleure façon d'y parvenir consiste à implémenter un complément qui vérifie le projet pour ces conditions.

Le présent article contient les sections suivantes :

• Création du complément

  • Stockage des erreurs de Validation

  • Spécification d'une Interface

  • Vérification des erreurs

  • Affiche les erreurs

  • Exécute la macro complémentaire à partir du ruban

  • Exécute la macro complémentaire avec un gestionnaire d'événements

• Débogage du complément

• Déploiement du complément

  • Sommaire

Création du complément

Dans cet article, le nom de la solution Visual Studio 2010, nom du projet, l'espace de noms et nom de l'assembly de complément sont tous les Project2010EditableAddIn. Procédure 1 montre comment créer le projet de complément principal. Procédure 2 montre comment créer un deuxième projet qui inclut des classes de stockage pour les règles de validation de la macro complémentaire. 3 De la procédure, vous ajoutez une définition d'interface pour la classe de règles de validation.

Procédure 1. Pour créer la macro complémentaire

1. Exécutez Visual Studio 2010 en tant qu'administrateur et puis créer un projet de complément Project 2010. Par exemple, nommez le projet Project2010EditableAddIn (Figure 1).

2. Dans le menu déroulant en haut de la boîte de dialogue Nouveau projet , sélectionnez .NET Framework 3.5. Désactivez la case à cocher créer le répertoire pour la solution et puis cliquez sur OK.

   Notes

   Pour obtenir une explication des différences entre l'utilisation de la.NET Framework 3.5 et le.NET Framework 4.0, voir Designing and Creating Office Solutions.

   La figure 1. Création d'un complément projet 2010

   

3. Dans le fichier ThisAddIn.cs, tapez la ligne suivante à l'intérieur de la méthode ThisAddIn_Startup : this.Application.ProjectBeforeSave2 +=

   Une fois que vous tapez les caractères += et appuyez sur Tab, Intellisense ajoute le reste de l'instruction automatiquement et inclut le nom de la méthode Application_ProjectBeforeSave2. Lorsque vous appuyez sur Tab à nouveau, Visual Studio ajoute la méthode de gestionnaire d'événements Application_ProjectBeforeSave2 avec l'instruction NotImplementedException, comme suit :

   using System;
   using System.Data;
   using MSProject = Microsoft.Office.Interop.MSProject;
   using Office = Microsoft.Office.Core;
   
   namespace Project2010EditableAddIn
   {
       public partial class ThisAddIn
       {
           private void ThisAddIn_Startup(object sender, System.EventArgs e)
           {
               this.Application.ProjectBeforeSave2 +=
                   new MSProject._EProjectApp2_ProjectBeforeSave2EventHandler(
                       Application_ProjectBeforeSave2);
           }
   
           void Application_ProjectBeforeSave2(MSProject.Project pj, bool SaveAsUi, 
               MSProject.EventInfo Info)
           {
               throw new NotImplementedException();
           }
   
           private void ThisAddIn_Shutdown(object sender, System.EventArgs e)
           {
           }
   
           // Code generated by VSTO.
           //    . . .
       }
   }
   

Stockage des erreurs de Validation

Le projet IValidationRules définit l'interface pour la classe ValidationRules et inclut la classe de ValidationError et de la classe de collection de ValidationErrors de stockage et de l'énumération des erreurs de validation.

Procédure 2. Pour créer des classes pour stocker les erreurs de validation

1. Dans l' Explorateur de solutions, cliquez droit sur la solution Project2010EditableAddIn (pas le projet), puis ajoutez un nouveau projet nommé IValidationRules.

2. Facultatif : Renommez l'espace de noms. Par exemple, nommer l'espace de noms du projet IValidationRulesMicrosoft.SDK.Project.Samples.ValidationRules.

3. Facultatif : Renommez le fichier de classe. Par exemple, nommez le fichier IRules.cs.

4. Ajouter une classe ValidationError qui peut stocker une instance d'un des message d'erreur et les données d'ID de tâche associée. Le constructeur de classe définit les propriétés Msg et TaskID de chaque instance.

   using System;
   using System.Data;
   using System.Collections;
   using System.Collections.Generic;
   using MSProject = Microsoft.Office.Interop.MSProject;
   
   namespace Microsoft.SDK.Project.Samples.ValidationRules
   {
       // Store one instance of a validation error.
       public class ValidationError
       {
           public ValidationError(string msg, int taskId)
           {
               this.Msg = msg;
               this.TaskID = taskId;
           }
   
           // Message property.
           public string Msg
           { get; set; }
   
           // Task ID property.
           public int TaskID
           { get; set; }
       }
       // . . .
   }
   

5. Ajoutez une classe nommée ValidationErrors qui peut stocker une collection d'objets de ValidationError et les énumérer. Le constructeur de classe initialise la variable de classe errors, qui est un objet List générique de type ValidationError.

   // Store a collection of validation errors.
   public class ValidationErrors : IEnumerable<ValidationError>
   {
       List<ValidationError> errors;
   
       public ValidationErrors()
       {
           errors = new List<ValidationError>();
       }
   
       public void Add(ValidationError error)
       {
           errors.Add(error);
       }
   
       public IEnumerator<ValidationError> GetEnumerator()
       {
           foreach (ValidationError err in errors)
           {
               yield return err;
           }
       }
   
       // Explicit interface implementation.
       IEnumerator IEnumerable.GetEnumerator()
       {
           return GetEnumerator();
       }
   }
   

Spécification d'une Interface

Une classe qui utilise l'interface IRules doit implémenter une méthode IsValid qui prend un paramètre project, une propriété de ErrorList de type ValidationErrors et une propriété de ErrorTable de type DataTable.

Procédure 3. Pour spécifier une interface pour la classe ValidationRules

1. Ajoutez les instructions suivantes de la using dans le fichier IRules.cs :

   using System.Collections;
   using MSProject = Microsoft.Office.Interop.MSProject;
   

2. Ajouter une interface nommée IRules.

3. Ajouter une définition de méthode IsValid, une propriété en lecture seule de ErrorList et une propriété en lecture seule de ErrorTable. Voici le code complet de l'interface IRules :

   // Specify the interface for the ValidationRules class.
   public interface IRules
   {
       bool IsValid(MSProject.Project project);
   
       ValidationErrors ErrorList { get; }
       DataTable ErrorTable { get; }
   }
   

Pour être en mesure d'hériter de l'interface IRules, compilez le projet de IValidationRules pour créer l'assembly IValidationRules.dll.

Vérification des erreurs

Créez une classe ValidationRules dans le projet Project2010EditableAddIn. La classe ValidationRules implémente la méthode et les propriétés de l'interface IRules. La méthode IsValid vérifie les erreurs et la propriété ErrorList stocke les données d'erreur. La propriété ErrorTable stocke les données pour une utilisation simple dans un contrôle DataGridView pour afficher les erreurs.

Procédure 4. Pour créer une classe qui vérifie les erreurs

1. Droit sur le projet Project2010EditableAddIn et ajoutez une classe nommée ValidationRules.

2. Définissez une référence à l'assembly IValidationRules.dll dans le sous-répertoire IValidationRules\bin\Debug du projet IValidationRules.

3. Ajouter à l'aide des instructions pour l'espace de noms ValidationRules et l'espace de noms MSProject.

4. Définissez une classe qui hérite de IRulesValidationRules.

5. Créer la variable de classe application de MSProject.Application de type, la variable errors de type ValidationErrors et la propriété NumErrors qui conserve un décompte d'erreurs. Initialisez les variables de classe et la propriété NumErrors dans le constructeur de classe, comme suit :

   using System;
   using System.Data;
   using MSProject = Microsoft.Office.Interop.MSProject;
   using Microsoft.SDK.Project.Samples.ValidationRules;
   
   namespace Project2010EditableAddIn
   {
       // The ValidationRules class must implement each member specified in the IRules interface.
       internal class ValidationRules : IRules
       {
           private MSProject.Application application;
           private ValidationErrors errors;
   
           internal ValidationRules(MSProject.Application app)
           {
               application = app;
               errors = new ValidationErrors();
               this.NumErrors = 0;
           }
   
           // Keep count of the number of errors.
           public int NumErrors
           { get; set; }
   
       }
   }
   

6. Créer des chaînes de ressource pour la méthode IsValid à utiliser dans les messages d'erreur :

   1. Dans l' Explorateur de solutions, développez le dossier Propriétés dans le projet Project2010EditableAddIn et double-cliquez sur Resource.resx. Créez les quatre propriétés et les valeurs, comme dans le tableau 1.

      Tableau 1. Les valeurs et les propriétés de la ressource

      nom ;	valeur
      MASTER_PROJECT	Ce projet est un projet principal.
      NULL_TASK	Cette tâche est null.
      FIXED_WORK_TASK	Cette tâche a un travail fixe.
      TASK_CALENDAR	Cette tâche a un calendrier des tâches

   2. Enregistrez et fermez Resources.resx. (La valeur de TASK_CALENDAR n'a aucune période à la fin).

7. Implémentez la méthode IsValid qui vérifie les conditions suivantes :

   • Si le projet contient des sous-projets, il s'agit d'un projet principal. Project Web App Impossible de modifier des projets principaux.

   • Vérifiez les tâches null.

   • Vérifiez les tâches qui sont un type de travail fixe.

   • Vérifiez les tâches qui utilisent un calendrier des tâches.

   Incrémenter la propriété NumErrors pour chaque erreur.

   // Check the project and all tasks for values that are not valid for editing in Project Web App. 
   // If any value is an error, the project cannot be edited.
   public bool IsValid(MSProject.Project project)
   {
       bool isValid = true;
   
       // If the project is a master project, the project is not valid.
       if (project.Subprojects.Count > 0)
       {
           isValid = false;
           this.NumErrors++;
   
           int taskId = 0;
           string validationErr = project.Name + ": " + Properties.Resources.FIXED_WORK_TASK;
           ErrorList.Add(new ValidationError(validationErr, taskId));
       }
   
       int index = 0;
       foreach (MSProject.Task task in project.Tasks)
       {
           index++;
   
           // If the task is null, the project is not valid.
           if (task == null)
           {
               isValid = false;
               this.NumErrors++;
               ErrorList.Add(new ValidationError(Properties.Resources.NULL_TASK, index));
   
               // Do not check any properties for the null task; 
               // otherwise, you get a null reference exception.
               continue; 
           }
   
           // If the task has fixed work, the project is not valid.
           if (task.Type == MSProject.PjTaskFixedType.pjFixedWork)
           {
               isValid = false;
               this.NumErrors++;
   
               string validationErr = task.Name + ": " + Properties.Resources.FIXED_WORK_TASK;
               ErrorList.Add(new ValidationError(validationErr, index));
           }
   
           // If the task has a task calendar, the project is not valid.
           if (!(task.Calendar == "None"))
           {
               isValid = false;
               this.NumErrors++;
   
               string validationErr = task.Name + ": " + Properties.Resources.TASK_CALENDAR;
               validationErr += ": " + task.Calendar;
               ErrorList.Add(new ValidationError(validationErr, index));
           }
       }
       return isValid;
   }
   

8. Implémentez la ErrorList en lecture seule propriété qui obtient l'objet errors de type ValidationErrors.

   // Retrieve the ErrorList, to add errors or read the collection of errors.
   public ValidationErrors ErrorList
   {
       get { return errors; }
   }
   

9. Implémenter la ErrorTable propriété en lecture seule, qui copie de chaque élément de ValidationError dans l'objet ErrorList dans un objet DataTable.

   // Build and return a DataSet with the validation errors.
   public DataTable ErrorTable
   {
       get
       {
           DataTable dtErrors = new DataTable("Errors");
           dtErrors.Columns.Add("TaskId", Type.GetType("System.String"));
           dtErrors.Columns.Add("Message", Type.GetType("System.String"));
   
           foreach (ValidationError error in ErrorList)
           {
               DataRow row = dtErrors.NewRow();
               row["TaskId"] = error.TaskID.ToString();
               row["Message"] = error.Msg;
               dtErrors.Rows.Add(row);
           }
           return dtErrors;
       }
   }
   

Affiche les erreurs

Lorsque Project2010EditableAddIn est exécuté, s'il y a des erreurs, une boîte de dialogue affiche la liste des erreurs qui sont stockés dans l'objet ErrorTable.

Procédure 5. Pour créer une boîte de dialogue qui affiche les erreurs

1. Dans l' Explorateur de solutions, cliquez droit sur le projet Project2010EditableAddIn et cliquez sur Ajouter, Windows Form.

2. Nommez la classe ErrorDialog.

3. Dans le volet Propriétés , définissez la propriété de Text de la classe ErrorDialogd'Erreursde Validation.

4. Définissez la propriété ControlBoxFalse.

5. Ajoutez un bouton à laErrorDialogformulaire, puis nommez le bouton texte « btnCancel ». Définissez la propriété Anchoren bas, à droite, la valeur de la propriété DialogResult pour Annuleret définissez la propriété Text à Annuler : ne pas enregistrer les.

6. Ajoutez un bouton à laErrorDialogformulaire, puis nommez le bouton btnOK. Définissez la propriété Anchoren bas, à droite, définissez la propriété de DialogResult sur OKet attribuez à la propriété TextOK: enregistrer quand même.

7. Dans la vue Design de ErrorDialog.cs, cliquez sur le formulaire d'Erreurs de Validation . Définissez la propriété AcceptButtonbtnOK. Définissez la propriété de CancelButton à btnCancel.

8. Ajoutez un contrôle DataGridView nommé dgErrors à la boîte de dialogue.

9. Ajouter une étiquette au-dessus du contrôle DataGridView. Pour cet exemple, nommez l' étiquette lblErrMess. Définissez la propriété de Text à une valeur temporaire ; par exemple, tapez les erreurs dans le projet. La méthode SetErrorCount dans la classe ErrorDialog modifie la propriété de Text. Développez la largeur d'étiquette pour couvrir la même largeur que le contrôle DataGridView (Figure 2). Développez la hauteur d'étiquette afin qu'elle peut afficher les quatre lignes de texte.

   La figure 2. En développant le contrôle Label dans la boîte de dialogue erreurs de Validation

   

10. Ajoutez le code suivant au fichier ErrorDialog.cs :

    using System;
    using System.Data;
    using System.Windows.Forms;
    
    namespace Project2010EditableAddIn
    {
        internal partial class ErrorDialog : Form
        {
            private int dlgWidth;
            private int dlgHeight;
    
            internal ErrorDialog()
            {
                InitializeComponent();
            }
    
            internal void SetErrors(DataTable dtErrors)
            {
                dgErrors.DataSource = dtErrors;
    
                // Set values for the grid user interface.
                dgErrors.Columns["TaskId"].HeaderText = "Task Number";
                dgErrors.Columns["TaskId"].AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
                dgErrors.Columns["Message"].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
            }
    
            // Change the label text to show the number of errors.
            internal void SetErrorCount(int numErrors)
            {
                lblErrMess.Text = "Number of errors: " + numErrors.ToString();
                lblErrMess.Text +=
                    "\n\nThe following errors in the project can prevent it from being editable";
                lblErrMess.Text += "\nin Project Web App.";
            }
    
            // Get the size of the dialog box before resizing.
            private void ErrorDialog_ResizeBegin(object sender, EventArgs e)
            {
                dlgWidth = this.Width;
                dlgHeight = this.Height;
            }
    
            // Calculate the new size of the DataGrid.
            private void ErrorDialog_ResizeEnd(object sender, EventArgs e)
            {
                dgErrors.Width += this.Width - dlgWidth;
                dgErrors.Height += this.Height - dlgHeight;
            }
        }
    }
    

11. Dans la vue Design du formulaire ErrorDialog, cliquez sur le formulaire et dans le volet Propriétés , cliquez sur l'icône Événements . Pour l'événement ResizeBegin, sélectionnez ErrorDialog_ResizeBegin dans la liste déroulante. Pour l'événement ResizeEnd, sélectionnez ErrorDialog_ResizeEnd dans la liste déroulante.

Le formulaire ErrorDialog est prêt à être instancié, initialisée et appelé dans le Gestionnaire d'événements Application_ProjectBeforeSave2 dans ThisAddIn.cs.

Exécute la macro complémentaire à partir du ruban

Créez un onglet du ruban et un bouton qui permet à l'utilisateur d'exécuter la vérification de validation à la demande.

Procédure 6. Pour ajouter un onglet du ruban et un bouton qui exécute la macro complémentaire

1. Dans l' Explorateur de solutions, cliquez droit sur le projet Project2010EditableAddIn et ensuite ajouter un nouvel élément. Dans la boîte de dialogue Ajouter un nouvel élément , cliquez sur ruban (concepteur visuel). Nommez la classe ValidationRibbon.

2. Développez l'onglet Contrôles du ruban Office dans la boîte à outils et faites glisser un contrôle bouton à Groupe1 dans l'onglet ValidationRibbon.cs [Design] .

3. Cliquez sur le contrôle group1 et désactivez la propriété Label afin qu'aucune étiquette de groupe est visible.

4. Cliquez sur le contrôle button1, modifiez la propriété LabelValidate pour l'édition de PWAet modifiez la propriété de Name en rbtnValidate.

5. Modifiez la propriété ControlSizeRibbonControlSizeLarge et puis modifiez la propriété de ScreenTip à la suivante : valide le projet dans Project Web App pour modification. Si le projet est un projet principal, ou contient une tâche null, une tâche travail fixe ou un calendrier des tâches, le projet ne peut pas être modifié dans PWA.

6. Cliquez sur la propriété Image (Figure 3) et puis d'importer une image du bouton à l'aide de la boîte de dialogue Sélectionner une ressource . Par exemple, importer l'image Checkmark.png dans le répertoire Samples\VSTO\Project2010EditableAddIn\Resources dans le téléchargement du Kit de développement logiciel de Project 2010.

   La figure 3. En mode Design pour le bouton de ruban de validation

   

7. Dans le volet Propriétés du bouton, cliquez sur l'icône Événements et double-cliquez sur l'événement Click pour créer le Gestionnaire d'événements rbtnValidate_Click.

8. Ajoutez du code au gestionnaire d'événements click qui affiche le formulaire ErrorDialog s'il existe des erreurs. S'il n'y a aucune erreur, afficher un message. Voici le Gestionnaire d'événements rbtnValidate_Click complète :

   // Click event handler for validation button on the ribbon.
   private void rbtnValidate_Click(object sender, RibbonControlEventArgs e)
   {
       try
       {
           ValidationRules rules = new ValidationRules(Globals.ThisAddIn.Application);
   
           if (!rules.IsValid(Globals.ThisAddIn.Application.ActiveProject))
           {
               ErrorDialog dlg = new ErrorDialog();
               dlg.SetErrors(rules.ErrorTable);
               dlg.SetErrorCount(rules.NumErrors);
               dlg.ShowDialog();
           }
           else
           {
               string msg = Globals.ThisAddIn.Application.ActiveProject.Name
                   + ":\nThis project is OK for editing in Project Web App.";
               MessageBox.Show(msg, "No Validation Errors", 
                   MessageBoxButtons.OK, MessageBoxIcon.Information);
           }
       }
       catch (Exception ex)
       {
           MessageBox.Show(ex.Message, "Exception", 
               MessageBoxButtons.OK, MessageBoxIcon.Error);
       }
   }
   

Lorsque l'utilisateur clique sur l'onglet Compléments du ruban, puis clique sur Valider pour l'édition de PWA, le complément logiciel valide le projet et affiche une liste des erreurs qui peuvent empêcher la modification dans Project Web App. S'il y a aucune erreur de la macro complémentaire n'affiche la boîte de message Aucune erreur de Validation (Figure 4).

La figure 4. Boîte de dialogue contenant le projet peut être modifié dans le projet Web App

Exécute la macro complémentaire avec un gestionnaire d'événements

Dans la procédure 1, Visual Studio a ajouté le stub de gestionnaire d'événements Application_ProjectBeforeSave2 lorsque vous avez ajouté l'événement ProjectBeforeSave2 à vérifier dans la méthode ThisAddIn_Startup. Pour terminer le complément, ajoutez le code dans le Gestionnaire d'événements Application_ProjectBeforeSave2.

Procédure 7. Pour créer le Gestionnaire d'événements ProjectBeforeSave2

1. Ouvrez ThisAddIn.cs, puis supprimez ou commenter les la ligne throw new NotImplementedException(); dans le Gestionnaire d'événements Application_ProjectBeforeSave2.

2. Ajoutez l'instruction suivante using, pour permettre l'utilisation de l'énumération DialogResult :

   using System.Windows.Forms;
   

3. Ajoutez du code dans le Gestionnaire d'événements Application_ProjectBeforeSave2 qui instancie un objet rules, puis appelle la méthode IsValid.

   // Event handler for the ProjectBeforeSave2 event.
   void Application_ProjectBeforeSave2(MSProject.Project pj, bool SaveAsUi,  MSProject.EventInfo Info)
   {
       if (pj == null) return;
   
       // Validate the project for editing in Project Web App.
       ValidationRules rules = new ValidationRules(this.Application);
   
       if (!rules.IsValid(pj))
       {
           // Show any validation errors.
           ErrorDialog dlg = new ErrorDialog();
           dlg.SetErrors(rules.ErrorTable);
           dlg.SetErrorCount(rules.NumErrors);
   
           // If the user clicks Cancel, cancel the save operation. 
           if (dlg.ShowDialog() == DialogResult.Cancel) Info.Cancel = true;
       }
   }
   

Lorsque l'utilisateur enregistre un projet, le Gestionnaire d'événements ProjectBeforeSave2 vérifie le projet et répertorie les erreurs dans la boîte de dialogue Erreurs de Validation (Figure 5). Si l'utilisateur clique sur Annuler : ne pas enregistrer les, le Gestionnaire d'événements définit la propriété de Info.Cancel à true et projet annule l'enregistrement opération. Si l'utilisateur clique OK: enregistrer quand même, Project enregistre les données. Le complément n'affiche pas la boîte de message Aucune erreur de Validation lorsqu'il utilise le Gestionnaire d'événements.

La figure 5. Boîte de dialogue affichant les erreurs d'application Web de projet

Débogage du complément

Projet de compléments de client sont un type de niveau application, pas un type de niveau document. Un complément de débogage pour le client du projet est simple. Visual Studio démarre le client du projet, puis s'arrête l'exécution à des points d'arrêt.

Procédure 8. Pour tester et déboguer le complément

1. Définissez un point d'arrêt dans lequel vous souhaitez démarrer le débogage. Par exemple, ouvrez le fichier ValidationRules.cs et puis de définir un point d'arrêt dans la méthode IsValid l'instruction de validationErr = task.Name + ": " + Properties.Resources.FIXED_WORK_TASK; de chaîne.

2. Si le client du projet est en cours d'exécution avant de démarrer une session de débogage, quittez Project.

3. Dans Visual Studio, appuyez sur F5 pour démarrer le débogage. Visual Studio commence le projet ; Vous pouvez exécuter le projet localement ou ouvrez une session avec un profil de Project Server. Dans le client de projet, créer certaines tâches et définissez l'une des tâches à un type de travail fixe.

4. Cliquez sur l'icône Enregistrer dans la barre d'outils Accès rapide (ou cliquez sur l'onglet Compléments dans le ruban et puis cliquez sur Valider pour l'édition de PWA). Visual Studio arrête le complément, le point d'arrêt.

5. Examiner les valeurs dans le volet variables locales et appuyez sur F11 pour l'étape les instructions et continuer dans le constructeur de classe ValidationError dans le fichier IRules.cs. Après avoir créé un objet ValidationError, l'exécution retourne à l'instruction Errorlist.Add et puis accède à la méthode Add dans la classe ValidationErrors. Lorsque le complément ajoute l'objet error, le volet variables locales montre que l'objet this.errors devient Count = 1.

Déploiement du complément

Vous pouvez utiliser l'Assistant Publication dans Visual Studio pour le déploiement de ClickOnce simple d'un projet de complément. Ces deux assemblys dans la solution doivent être signés avec une clé de nom fort. Pour plus d'informations, consultez How to: Deploy an Office Solution by Using ClickOnce dans MSDN Library.

Procédure 9. Pour déployer le complément Project Professional

1. Dans l' Explorateur de solutions, cliquez droit sur le projet IValidationRules et puis cliquez sur Propriétés. Sous l'onglet IValidationRules , cliquez sur l'onglet Signature , activez la case à cocher Signer l’assembly et puis créer un fichier de clé de nom fort. Par exemple, créer des IValidationRules.snk.

2. De même, créez un fichier de clé de nom fort pour le projet Project2010EditableAddIn. Par exemple, créer des Project2010Addin.snk.

3. Droit sur le projet Project2010EditableAddIn et puis cliquez sur Publier.

4. Sur la première page de l' Assistant Publication, modifiez le nom du répertoire publish\ par défaut pour le rendre facile à reconnaître sur un autre ordinateur. Par exemple, remplacez le nom Project2010EditableAddIn_Published\. Cliquez sur Suivant.

5. Dans la deuxième page de l' Assistant Publication, choisissez l'option par défaut à partir d'un CD-ROM ou DVD-ROM . Cliquez sur Suivantet puis cliquez sur Terminer. Visual Studio reconstruit les projets, si nécessaire et puis crée le sous-répertoire Project2010EditableAddIn_Published\ et les fichiers de déploiement du complément à un autre ordinateur.

6. Copiez le répertoire Project2010EditableAddIn_Published\ vers un autre ordinateur, où Project Professionnel 2010 est installé.

7. Sur l'ordinateur, exécutez setup.exe dans le répertoire Project2010EditableAddIn_Published\. L'Assistant Installation de personnalisation de Microsoft Office vérifie les conditions préalables. Dans la page de Publisher ne peut pas être vérifiée , de l'Assistant, cliquez sur Installer. Après que l'installation est terminée, cliquez sur Fermer.

Lorsque vous exécutez le projet, vous devriez voir Validate pour PWA modification sous l'onglet Compléments du ruban. Créer des tâches ; Ajouter une tâche travail fixe, une tâche null et une tâche qui a un calendrier des tâches. Lorsque vous enregistrez le projet, vous devriez voir la boîte de dialogue Erreurs de Validation dans la Figure 5. Une fois que vous corrigez les erreurs et puis cliquez sur Valider pour l'édition de PWA sur le ruban, vous devriez voir la boîte de message Aucune erreur de Validation dans la Figure 4.

Sommaire

Visual Studio 2010 permet de construire et déployer Project 2010 complémentaires plus faciles. L'exemple Project2010EditableAddIn montre comment créer et déployer un complément Project 2010 vérifie si un projet est modifiable dans Project Web App.

Voir aussi

Autres ressources

Designing and Creating Office Solutions

How to: Deploy an Office Solution by Using ClickOnce