Partager via


Gérer les projets Windows universels

Les applications Windows universelles sont des applications qui ciblent Windows 8.1 et Windows Téléphone 8.1, ce qui permet aux développeurs d’utiliser du code et d’autres ressources sur les deux plateformes. Le code partagé et les ressources sont conservés dans un projet partagé, tandis que le code et les ressources spécifiques à la plateforme sont conservés dans des projets distincts, l’un pour Windows et l’autre pour Windows Téléphone. Pour plus d’informations sur les applications Windows universelles, consultez applications Windows universelles. Les extensions Visual Studio qui gèrent les projets doivent être conscientes que les projets d’application Windows universelle ont une structure qui diffère des applications à plateforme unique. Cette procédure pas à pas vous montre comment naviguer dans le projet partagé et gérer les éléments partagés.

  1. Créez un projet VSIX C# nommé TestUniversalProject. (Fichier>nouveau>projet, puis package Visual Studio C#>Extensibility).> Ajoutez un modèle d’élément de projet Commande personnalisée (sur le Explorateur de solutions, cliquez avec le bouton droit sur le nœud du projet, puis sélectionnez Ajouter>un nouvel élément, puis accédez à Extensibilité). Nommez le fichier TestUniversalProject.

  2. Ajoutez une référence à Microsoft.VisualStudio.Shell.Interop.12.1.DesignTime.dll et Microsoft.VisualStudio.Shell.Interop.14.0.DesignTime.dll (dans la section Extensions ).

  3. Ouvrez TestUniversalProject.cs et ajoutez les directives suivantes using :

    using EnvDTE;
    using EnvDTE80;
    using Microsoft.VisualStudio;
    using Microsoft.VisualStudio.PlatformUI;
    using Microsoft.Internal.VisualStudio.PlatformUI;
    using System.Collections.Generic;
    using System.IO;
    using System.Windows.Forms;
    
  4. Dans la TestUniversalProject classe, ajoutez un champ privé pointant vers la fenêtre Sortie .

    public sealed class TestUniversalProject
    {
        IVsOutputWindowPane output;
    . . .
    }
    
  5. Définissez la référence au volet de sortie dans le constructeur TestUniversalProject :

    private TestUniversalProject(Package package)
    {
        if (package == null)
        {
            throw new ArgumentNullException("package");
        }
    
        this.package = package;
    
        OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
        if (commandService != null)
        {
            CommandID menuCommandID = new CommandID(MenuGroup, CommandId);
            EventHandler eventHandler = this.ShowMessageBox;
            MenuCommand menuItem = new MenuCommand(eventHandler, menuCommandID);
            commandService.AddCommand(menuItem);
        }
    
        // get a reference to the Output window
        output = (IVsOutputWindowPane)ServiceProvider.GetService(typeof(SVsGeneralOutputWindowPane));
    }
    
  6. Supprimez le code existant de la ShowMessageBox méthode :

    private void ShowMessageBox(object sender, EventArgs e)
    {
    }
    
  7. Obtenez l’objet DTE, que nous utiliserons à plusieurs fins différentes dans cette procédure pas à pas. Vérifiez également qu’une solution est chargée lorsque le bouton de menu est cliqué.

    private void ShowMessageBox(object sender, EventArgs e)
    {
        var dte = (EnvDTE.DTE)this.ServiceProvider.GetService(typeof(EnvDTE.DTE));
        if (dte.Solution != null)
        {
            . . .
        }
        else
        {
            MessageBox.Show("No solution is open");
            return;
        }
    }
    
  8. Recherchez le projet partagé. Le projet partagé est un conteneur pur ; il ne génère pas de sorties ou ne génère pas de sorties. La méthode suivante recherche le premier projet partagé dans la solution en recherchant l’objet IVsHierarchy doté de la fonctionnalité de projet partagé.

    private IVsHierarchy FindSharedProject()
    {
        var sln = (IVsSolution)this.ServiceProvider.GetService(typeof(SVsSolution));
        Guid empty = Guid.Empty;
        IEnumHierarchies enumHiers;
    
        //get all the projects in the solution
        ErrorHandler.ThrowOnFailure(sln.GetProjectEnum((uint)__VSENUMPROJFLAGS.EPF_LOADEDINSOLUTION, ref empty, out enumHiers));
        foreach (IVsHierarchy hier in ComUtilities.EnumerableFrom(enumHiers))
        {
            if (PackageUtilities.IsCapabilityMatch(hier, "SharedAssetsProject"))
            {
                return hier;
            }
        }
        return null;
    }
    
  9. Dans la ShowMessageBox méthode, affichez le légende (nom du projet qui apparaît dans le Explorateur de solutions) du projet partagé.

    private void ShowMessageBox(object sender, EventArgs e)
    {
        var dte = (DTE)this.ServiceProvider.GetService(typeof(DTE));
    
        if (dte.Solution != null)
        {
            var sharedHier = this.FindSharedProject();
            if (sharedHier != null)
            {
                string sharedCaption = HierarchyUtilities.GetHierarchyProperty<string>(sharedHier, (uint)VSConstants.VSITEMID.Root,
                     (int)__VSHPROPID.VSHPROPID_Caption);
                output.OutputStringThreadSafe(string.Format("Found shared project: {0}\n", sharedCaption));
            }
            else
            {
                MessageBox.Show("Solution has no shared project");
                return;
            }
        }
        else
        {
            MessageBox.Show("No solution is open");
            return;
        }
    }
    
  10. Obtenez le projet de plateforme active. Les projets de plateforme sont les projets qui contiennent du code et des ressources spécifiques à la plateforme. La méthode suivante utilise le nouveau champ VSHPROPID_SharedItemContextHierarchy pour obtenir le projet de plateforme active.

    private IVsHierarchy GetActiveProjectContext(IVsHierarchy hierarchy)
    {
        IVsHierarchy activeProjectContext;
        if (HierarchyUtilities.TryGetHierarchyProperty(hierarchy, (uint)VSConstants.VSITEMID.Root,
             (int)__VSHPROPID7.VSHPROPID_SharedItemContextHierarchy, out activeProjectContext))
        {
            return activeProjectContext;
        }
        else
        {
            return null;
        }
    }
    
  11. Dans la ShowMessageBox méthode, affichez la légende du projet de plateforme active.

    private void ShowMessageBox(object sender, EventArgs e)
    {
        var dte = (DTE)this.ServiceProvider.GetService(typeof(DTE));
    
        if (dte.Solution != null)
        {
            var sharedHier = this.FindSharedProject();
            if (sharedHier != null)
            {
                string sharedCaption = HierarchyUtilities.GetHierarchyProperty<string>(sharedHier, (uint)VSConstants.VSITEMID.Root,
                     (int)__VSHPROPID.VSHPROPID_Caption);
                output.OutputStringThreadSafe(string.Format("Shared project: {0}\n", sharedCaption));
    
                var activePlatformHier = this.GetActiveProjectContext(sharedHier);
                if (activePlatformHier != null)
                {
                    string activeCaption = HierarchyUtilities.GetHierarchyProperty<string>(activePlatformHier,
                         (uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID.VSHPROPID_Caption);
                    output.OutputStringThreadSafe(string.Format("Active platform project: {0}\n", activeCaption));
                }
                else
                {
                    MessageBox.Show("Shared project has no active platform project");
                }
            }
            else
            {
                MessageBox.Show("Solution has no shared project");
            }
        }
        else
        {
            MessageBox.Show("No solution is open");
        }
    }
    
  12. Effectuez une itération dans les projets de plateforme. La méthode suivante obtient tous les projets d’importation (plateforme) à partir du projet partagé.

    private IEnumerable<IVsHierarchy> EnumImportingProjects(IVsHierarchy hierarchy)
    {
        IVsSharedAssetsProject sharedAssetsProject;
        if (HierarchyUtilities.TryGetHierarchyProperty(hierarchy, (uint)VSConstants.VSITEMID.Root,
            (int)__VSHPROPID7.VSHPROPID_SharedAssetsProject, out sharedAssetsProject)
            && sharedAssetsProject != null)
        {
            foreach (IVsHierarchy importingProject in sharedAssetsProject.EnumImportingProjects())
            {
                yield return importingProject;
            }
        }
    }
    

    Important

    Si l’utilisateur a ouvert un projet d’application Windows universelle C++ dans l’instance expérimentale, le code ci-dessus lève une exception. Il s’agit d’un problème connu. Pour éviter l’exception, remplacez le foreach bloc ci-dessus par les éléments suivants :

    var importingProjects = sharedAssetsProject.EnumImportingProjects();
    for (int i = 0; i < importingProjects.Count; ++i)
    {
        yield return importingProjects[i];
    }
    
  13. Dans la ShowMessageBox méthode, affichez la légende de chaque projet de plateforme. Insérez le code suivant après la ligne qui génère la légende du projet de plateforme active. Seuls les projets de plateforme chargés apparaissent dans cette liste.

    output.OutputStringThreadSafe("Platform projects:\n");
    
    IEnumerable<IVsHierarchy> projects = this.EnumImportingProjects(sharedHier);
    
    bool isActiveProjectSet = false;
    foreach (IVsHierarchy platformHier in projects)
    {
        string platformCaption = HierarchyUtilities.GetHierarchyProperty<string>(platformHier, (uint)VSConstants.VSITEMID.Root,
            (int)__VSHPROPID.VSHPROPID_Caption);
        output.OutputStringThreadSafe(string.Format(" * {0}\n", platformCaption));
    }
    
  14. Modifiez le projet de plateforme active. La méthode suivante définit le projet actif à l’aide SetPropertyde .

    private int SetActiveProjectContext(IVsHierarchy hierarchy, IVsHierarchy activeProjectContext)
    {
        return hierarchy.SetProperty((uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID7.VSHPROPID_SharedItemContextHierarchy, activeProjectContext);
    }
    
  15. Dans la ShowMessageBox méthode, modifiez le projet de plateforme active. Insérez ce code à l’intérieur du foreach bloc.

    bool isActiveProjectSet = false;
    string platformCaption = null;
    foreach (IVsHierarchy platformHier in projects)
    {
        platformCaption = HierarchyUtilities.GetHierarchyProperty<string>(platformHier, (uint)VSConstants.VSITEMID.Root,
             (int)__VSHPROPID.VSHPROPID_Caption);
        output.OutputStringThreadSafe(string.Format(" * {0}\n", platformCaption));
    
        // if this project is neither the shared project nor the current active platform project,
        // set it to be the active project
        if (!isActiveProjectSet && platformHier != activePlatformHier)
        {
            this.SetActiveProjectContext(sharedHier, platformHier);
            activePlatformHier = platformHier;
            isActiveProjectSet = true;
        }
    }
    output.OutputStringThreadSafe("set active project: " + platformCaption +'\n');
    
  16. Essayez-le maintenant. Appuyez sur F5 pour lancer l’instance expérimentale. Créez un projet d’application hub universel C# dans l’instance expérimentale (dans la boîte de dialogue Nouveau projet, Application Hub universel>Windows Windows>8>Visual C#).> Une fois la solution chargée, accédez au menu Outils et cliquez sur Invoke TestUniversalProject, puis case activée le texte dans le volet Sortie. Un résultat tel que celui-ci doit s’afficher :

    Found shared project: HubApp.Shared
    The active platform project: HubApp.Windows
    Platform projects:
     * HubApp.Windows
     * HubApp.WindowsPhone
    set active project: HubApp.WindowsPhone
    

Gérer les éléments partagés dans le projet de plateforme

  1. Recherchez les éléments partagés dans le projet de plateforme. Les éléments du projet partagé apparaissent dans le projet de plateforme en tant qu’éléments partagés. Vous ne pouvez pas les voir dans le Explorateur de solutions, mais vous pouvez parcourir la hiérarchie du projet pour les trouver. La méthode suivante décrit la hiérarchie et collecte tous les éléments partagés. Il génère éventuellement la légende de chaque élément. Les éléments partagés sont identifiés par la nouvelle propriété VSHPROPID_IsSharedItem.

    private void InspectHierarchyItems(IVsHierarchy hier, uint itemid, int level, List<uint> itemIds, bool getSharedItems, bool printItems)
    {
        string caption = HierarchyUtilities.GetHierarchyProperty<string>(hier, itemid, (int)__VSHPROPID.VSHPROPID_Caption);
        if (printItems)
            output.OutputStringThreadSafe(string.Format("{0}{1}\n", new string('\t', level), caption));
    
        // if getSharedItems is true, inspect only shared items; if it's false, inspect only unshared items
        bool isSharedItem;
        if (HierarchyUtilities.TryGetHierarchyProperty(hier, itemid, (int)__VSHPROPID7.VSHPROPID_IsSharedItem, out isSharedItem)
            && (isSharedItem == getSharedItems))
        {
            itemIds.Add(itemid);
        }
    
        uint child;
        if (HierarchyUtilities.TryGetHierarchyProperty(hier, itemid, (int)__VSHPROPID.VSHPROPID_FirstChild, Unbox.AsUInt32, out child)
            && child != (uint)VSConstants.VSITEMID.Nil)
        {
            this.InspectHierarchyItems(hier, child, level + 1, itemIds, isSharedItem, printItems);
    
            while (HierarchyUtilities.TryGetHierarchyProperty(hier, child, (int)__VSHPROPID.VSHPROPID_NextSibling, Unbox.AsUInt32, out child)
                && child != (uint)VSConstants.VSITEMID.Nil)
            {
                this.InspectHierarchyItems(hier, child, level + 1, itemIds, isSharedItem, printItems);
            }
        }
    }
    
  2. Dans la ShowMessageBox méthode, ajoutez le code suivant pour parcourir les éléments de hiérarchie de projet de plateforme. Insérez-le à l’intérieur du foreach bloc.

    output.OutputStringThreadSafe("Walk the active platform project:\n");
    var sharedItemIds = new List<uint>();
    this.InspectHierarchyItems(activePlatformHier, (uint)VSConstants.VSITEMID.Root, 1, sharedItemIds, true, true);
    
  3. Lisez les éléments partagés. Les éléments partagés apparaissent dans le projet de plateforme sous forme de fichiers liés masqués, et vous pouvez lire toutes les propriétés en tant que fichiers liés ordinaires. Le code suivant lit le chemin complet du premier élément partagé.

    var sharedItemId = sharedItemIds[0];
    string fullPath;
    ErrorHandler.ThrowOnFailure(((IVsProject)activePlatformHier).GetMkDocument(sharedItemId, out fullPath));
    output.OutputStringThreadSafe(string.Format("Shared item full path: {0}\n", fullPath));
    
  4. Essayez-le maintenant. Appuyez sur F5 pour lancer l’instance expérimentale. Créez un projet d’application hub universel C# dans l’instance expérimentale (dans la boîte de dialogue Nouveau projet, Visual C#>Windows>8>Universal>Hub App) accédez au menu Outils, puis cliquez sur Invoke TestUniversalProject, puis case activée le texte dans le volet Sortie. Un résultat tel que celui-ci doit s’afficher :

    Found shared project: HubApp.Shared
    The active platform project: HubApp.Windows
    Platform projects:
     * HubApp.Windows
     * HubApp.WindowsPhone
    set active project: HubApp.WindowsPhone
    Walk the active platform project:
        HubApp.WindowsPhone
            <HubApp.Shared>
                App.xaml
                    App.xaml.cs
                Assets
                    DarkGray.png
                    LightGray.png
                    MediumGray.png
                Common
                    NavigationHelper.cs
                    ObservableDictionary.cs
                    RelayCommand.cs
                    SuspensionManager.cs
                DataModel
                    SampleData.json
                    SampleDataSource.cs
                HubApp.Shared.projitems
                Strings
                    en-US
                        Resources.resw
            Assets
                HubBackground.theme-dark.png
                HubBackground.theme-light.png
                Logo.scale-240.png
                SmallLogo.scale-240.png
                SplashScreen.scale-240.png
                Square71x71Logo.scale-240.png
                StoreLogo.scale-240.png
                WideLogo.scale-240.png
            HubPage.xaml
                HubPage.xaml.cs
            ItemPage.xaml
                ItemPage.xaml.cs
            Package.appxmanifest
            Properties
                AssemblyInfo.cs
            References
                .NET for Windows Store apps
                HubApp.Shared
                Windows Phone 8.1
            SectionPage.xaml
                SectionPage.xaml.cs
    

Détecter les modifications apportées aux projets de plateforme et aux projets partagés

  1. Vous pouvez utiliser des événements de hiérarchie et de projet pour détecter les modifications apportées aux projets partagés, tout comme vous pouvez pour les projets de plateforme. Toutefois, les éléments du projet dans le projet partagé ne sont pas visibles, ce qui signifie que certains événements ne se déclenchent pas lorsque les éléments de projet partagés sont modifiés.

    Tenez compte de la séquence d’événements lorsqu’un fichier d’un projet est renommé :

    1. Le nom du fichier est modifié sur le disque.

    2. Le fichier projet est mis à jour pour inclure le nouveau nom du fichier.

      Les événements de hiérarchie (par exemple) IVsHierarchyEventssuivent généralement les modifications affichées dans l’interface utilisateur, comme dans le Explorateur de solutions. Les événements de hiérarchie considèrent une opération de renommage de fichier pour se composer d’une suppression de fichier, puis d’un ajout de fichier. Toutefois, lorsque des éléments invisibles sont modifiés, le système d’événements de hiérarchie déclenche un OnItemDeleted événement, mais pas un OnItemAdded événement. Par conséquent, si vous renommez un fichier dans un projet de plateforme, vous obtenez à la fois OnItemDeleted et OnItemAdded, si vous renommez un fichier dans un projet partagé, vous obtenez uniquement OnItemDeleted.

      Pour suivre les modifications apportées aux éléments de projet, vous pouvez gérer les événements d’élément de projet DTE (ceux trouvés dans ProjectItemsEventsClass). Toutefois, si vous gérez un grand nombre d’événements, vous pouvez obtenir de meilleures performances de gestion des événements dans IVsTrackProjectDocuments2. Dans cette procédure pas à pas, nous affichons uniquement les événements de hiérarchie et les événements DTE. Dans cette procédure, vous ajoutez un écouteur d’événements à un projet partagé et un projet de plateforme. Ensuite, lorsque vous renommez un fichier dans un projet partagé et un autre fichier dans un projet de plateforme, vous pouvez voir les événements déclenchés pour chaque opération de renommage.

      Dans cette procédure, vous ajoutez un écouteur d’événements à un projet partagé et un projet de plateforme. Ensuite, lorsque vous renommez un fichier dans un projet partagé et un autre fichier dans un projet de plateforme, vous pouvez voir les événements déclenchés pour chaque opération de renommage.

  2. Ajoutez un écouteur d’événements. Ajoutez un nouveau fichier de classe au projet et appelez-le HierarchyEventListener.cs.

  3. Ouvrez le fichier HierarchyEventListener.cs et ajoutez les directives using suivantes :

    using Microsoft.VisualStudio.Shell.Interop;
    using Microsoft.VisualStudio;
    using System.IO;
    
  4. Mettre en œuvre IVsHierarchyEventsla HierarchyEventListener classe :

    class HierarchyEventListener : IVsHierarchyEvents
    { }
    
  5. Implémentez les membres de IVsHierarchyEvents, comme dans le code ci-dessous.

    class HierarchyEventListener : IVsHierarchyEvents
    {
        private IVsHierarchy hierarchy;
        IVsOutputWindowPane output;
    
        internal HierarchyEventListener(IVsHierarchy hierarchy, IVsOutputWindowPane outputWindow) {
             this.hierarchy = hierarchy;
             this.output = outputWindow;
        }
    
        int IVsHierarchyEvents.OnInvalidateIcon(IntPtr hIcon) {
            return VSConstants.S_OK;
        }
    
        int IVsHierarchyEvents.OnInvalidateItems(uint itemIDParent) {
            return VSConstants.S_OK;
        }
    
        int IVsHierarchyEvents.OnItemAdded(uint itemIDParent, uint itemIDSiblingPrev, uint itemIDAdded) {
            output.OutputStringThreadSafe("IVsHierarchyEvents.OnItemAdded: " + itemIDAdded + "\n");
            return VSConstants.S_OK;
        }
    
        int IVsHierarchyEvents.OnItemDeleted(uint itemID) {
            output.OutputStringThreadSafe("IVsHierarchyEvents.OnItemDeleted: " + itemID + "\n");
            return VSConstants.S_OK;
        }
    
        int IVsHierarchyEvents.OnItemsAppended(uint itemIDParent) {
            output.OutputStringThreadSafe("IVsHierarchyEvents.OnItemsAppended\n");
            return VSConstants.S_OK;
        }
    
        int IVsHierarchyEvents.OnPropertyChanged(uint itemID, int propID, uint flags) {
            output.OutputStringThreadSafe("IVsHierarchyEvents.OnPropertyChanged: item ID " + itemID + "\n");
            return VSConstants.S_OK;
        }
    }
    
  6. Dans la même classe, ajoutez un autre gestionnaire d’événements pour l’événement ItemRenamedDTE, qui se produit chaque fois qu’un élément de projet est renommé.

    public void OnItemRenamed(EnvDTE.ProjectItem projItem, string oldName)
    {
        output.OutputStringThreadSafe(string.Format("[Event] Renamed {0} to {1} in project {2}\n",
             oldName, Path.GetFileName(projItem.get_FileNames(1)), projItem.ContainingProject.Name));
    }
    
  7. Inscrivez-vous aux événements de hiérarchie. Vous devez vous inscrire séparément pour chaque projet que vous suivez. Ajoutez le code suivant dans ShowMessageBox, un pour le projet partagé et l’autre pour l’un des projets de plateforme.

    // hook up the event listener for hierarchy events on the shared project
    HierarchyEventListener listener1 = new HierarchyEventListener(sharedHier, output);
    uint cookie1;
    sharedHier.AdviseHierarchyEvents(listener1, out cookie1);
    
    // hook up the event listener for hierarchy events on the
    active project
    HierarchyEventListener listener2 = new HierarchyEventListener(activePlatformHier, output);
    uint cookie2;
    activePlatformHier.AdviseHierarchyEvents(listener2, out cookie2);
    
  8. Inscrivez-vous à l’événement ItemRenamedd’élément de projet DTE . Ajoutez le code suivant après avoir branché le deuxième écouteur.

    // hook up DTE events for project items
    Events2 dteEvents = (Events2)dte.Events;
    dteEvents.ProjectItemsEvents.ItemRenamed += listener1.OnItemRenamed;
    
  9. Modifiez l’élément partagé. Vous ne pouvez pas modifier les éléments partagés dans un projet de plateforme ; Au lieu de cela, vous devez les modifier dans le projet partagé qui est le propriétaire réel de ces éléments. Vous pouvez obtenir l’ID d’élément correspondant dans le projet partagé avec IsDocumentInProject, en lui donnant le chemin complet de l’élément partagé. Vous pouvez ensuite modifier l’élément partagé. La modification est propagée aux projets de plateforme.

    Important

    Vous devez déterminer si un élément de projet est ou non un élément partagé avant de le modifier.

    La méthode suivante modifie le nom d’un fichier d’élément de projet.

    private void ModifyFileNameInProject(IVsHierarchy project, string path)
    {
        int found;
        uint projectItemID;
        VSDOCUMENTPRIORITY[] priority = new VSDOCUMENTPRIORITY[1];
        if (ErrorHandler.Succeeded(((IVsProject)project).IsDocumentInProject(path, out found, priority, out projectItemID))
            && found != 0)
        {
            var name = DateTime.Now.Ticks.ToString() + Path.GetExtension(path);
            project.SetProperty(projectItemID, (int)__VSHPROPID.VSHPROPID_EditLabel, name);
            output.OutputStringThreadSafe(string.Format("Renamed {0} to {1}\n", path,name));
        }
    }
    
  10. Appelez cette méthode après l’ensemble du code dans ShowMessageBox lequel modifier le nom de fichier de l’élément dans le projet partagé. Insérez-le après le code qui obtient le chemin complet de l’élément dans le projet partagé.

    // change the file name of an item in a shared project
    this.InspectHierarchyItems(activePlatformHier, (uint)VSConstants.VSITEMID.Root, 1, sharedItemIds, true, true);
    ErrorHandler.ThrowOnFailure(((IVsProject)activePlatformHier).GetMkDocument(sharedItemId, out fullPath));
    output.OutputStringThreadSafe(string.Format("Shared project item ID = {0}, full path = {1}\n", sharedItemId, fullPath));
    this.ModifyFileNameInProject(sharedHier, fullPath);
    
  11. Générez et exécutez le projet. Créez une application hub universel C# dans l’instance expérimentale, accédez au menu Outils, puis cliquez sur Invoke TestUniversalProject, puis case activée le texte dans le volet de sortie général. Le nom du premier élément du projet partagé (nous nous attendons à ce qu’il soit le fichier App.xaml ) doit être modifié et vous devez voir que l’événement ItemRenamed a été déclenché. Dans ce cas, étant donné que le changement de nom d’App.xaml entraîne le renommage d’App.xaml.cs, vous devez également voir quatre événements (deux pour chaque projet de plateforme). (Les événements DTE ne suivent pas les éléments du projet partagé.) Vous devez voir deux OnItemDeleted événements (un pour chacun des projets de plateforme), mais aucun OnItemAdded événement.

  12. Essayez maintenant de renommer un fichier dans un projet de plateforme, et vous pouvez voir la différence dans les événements déclenchés. Ajoutez le code ShowMessageBox suivant après l’appel à ModifyFileName.

    // change the file name of an item in a platform project
    var unsharedItemIds = new List<uint>();
    this.InspectHierarchyItems(activePlatformHier, (uint)VSConstants.VSITEMID.Root, 1, unsharedItemIds, false, false);
    
    var unsharedItemId = unsharedItemIds[0];
    string unsharedPath;
    ErrorHandler.ThrowOnFailure(((IVsProject)activePlatformHier).GetMkDocument(unsharedItemId, out unsharedPath));
    output.OutputStringThreadSafe(string.Format("Platform project item ID = {0}, full path = {1}\n", unsharedItemId, unsharedPath));
    
    this.ModifyFileNameInProject(activePlatformHier, unsharedPath);
    
  13. Générez et exécutez le projet. Créez un projet universel C# dans l’instance expérimentale, accédez au menu Outils, puis cliquez sur Invoke TestUniversalProject, puis case activée le texte dans le volet de sortie général. Une fois le fichier du projet de plateforme renommé, vous devez voir à la fois un OnItemAdded événement et un OnItemDeleted événement. Étant donné que la modification du fichier n’a provoqué aucune modification d’autres fichiers et que les modifications apportées aux éléments d’un projet de plateforme n’ont pas été propagées n’importe où, il n’y a qu’un seul de ces événements.