La gestion des projets Windows universelManaging Universal Windows Projects

Les applications Windows universelles sont des applications qui ciblent Windows 8.1 et Windows Phone 8.1, permettant aux développeurs d’utiliser du code et autres ressources sur les deux plateformes.Universal Windows apps are apps that target both Windows 8.1 and Windows Phone 8.1, allowing developers to use code and other assets on both platforms. Le code partagé et les ressources sont conservés dans un projet partagé, tandis que le code spécifique à la plateforme et les ressources sont conservées dans des projets séparés, un pour Windows et l’autre pour Windows Phone.The shared code and resources are kept in a shared project, while the platform-specific code and resources are kept in separate projects, one for Windows and the other for Windows Phone. Pour plus d’informations sur les applications Windows universelles, consultez les applications Windows universelles.For more information about universal Windows apps, see Universal Windows Apps. Les extensions Visual Studio qui gèrent les projets Sachez que les projets d’application Windows universelles ont une structure différente de celle à partir d’applications de plate-forme unique.Visual Studio extensions that manage projects should be aware that universal Windows app projects have a structure that differs from single-platform apps. Cette procédure pas à pas montre comment naviguer dans le projet partagé et de gérer les éléments partagés.This walkthrough shows you how to navigate the shared project and manage the shared items.

PrérequisPrerequisites

À partir de Visual Studio 2015, vous n’installez pas le Kit de développement logiciel Visual Studio à partir du centre de téléchargement.Starting in Visual Studio 2015, you do not install the Visual Studio SDK from the download center. Il est inclus comme une fonctionnalité facultative dans le programme d’installation de Visual Studio.It is included as an optional feature in Visual Studio setup. Vous pouvez également installer le kit SDK VS ultérieurement.You can also install the VS SDK later on. Pour plus d’informations, consultez l’installation de Visual Studio SDK.For more information, see Installing the Visual Studio SDK.

  1. Créez un projet VSIX c# nommé TestUniversalProject.Create a C# VSIX project named TestUniversalProject. (Fichier, nouveau, projet , puis c#, d’extensibilité, de Package Visual Studio).(File, New, Project and then C#, Extensibility, Visual Studio Package). Ajouter un commande personnalisée modèle d’élément de projet (dans l’Explorateur de solutions, cliquez sur le nœud du projet et sélectionnez Ajouter / nouvel élément, puis accédez à extensibilité).Add a Custom Command project item template (on the Solution Explorer, right-click the project node and select Add / New Item, then go to Extensibility). Nommez le fichier TestUniversalProject.Name the file 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 le Extensions section).Add a reference to Microsoft.VisualStudio.Shell.Interop.12.1.DesignTime.dll and Microsoft.VisualStudio.Shell.Interop.14.0.DesignTime.dll (in the Extensions section).

  3. Ouvrez TestUniversalProject.cs et ajoutez le code suivant using instructions :Open TestUniversalProject.cs and add the following using statements:

    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 classe TestUniversalProject, ajoutez un champ privé pointant vers le sortie fenêtre.In the TestUniversalProject class add a private field pointing to the Output window.

    public sealed class TestUniversalProject   
    {  
        IVsOutputWindowPane output;  
    . . .  
    }  
    
  5. Définir la référence dans le volet de sortie à l’intérieur du constructeur de TestUniversalProject :Set the reference to the output pane inside TestUniversalProject constructor:

    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 à partir de la ShowMessageBox méthode :Remove the existing code from the ShowMessageBox method:

    private void ShowMessageBox(object sender, EventArgs e)   
    {  
    }  
    
  7. Obtient l’objet DTE, que nous utiliserons pour plusieurs objectifs différents dans cette procédure pas à pas.Get the DTE object, which we will use for several different purposes in this walkthrough. En outre, assurez-vous qu’une solution est chargée lorsque l’utilisateur clique sur le bouton de menu.Also, make sure that a solution is loaded when the menu button is clicked.

    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é.Find the shared project. Le projet partagé est un conteneur pur ; Il ne pas générer ou générer des sorties.The shared project is a pure container; it does not build or produce outputs. La méthode suivante recherche le premier projet partagé dans la solution en recherchant le IVsHierarchy objet ayant la fonctionnalité de projet partagé.The following method finds the first shared project in the solution by looking for the IVsHierarchy object that has the shared project capability.

    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 le ShowMessageBox (méthode), la légende de sortie (le nom du projet qui s’affiche dans le l’Explorateur de solutions) du projet partagé.In the ShowMessageBox method, output the caption (the project name that appears in the Solution Explorer) of the shared project.

    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. Obtenir le projet pour la plateforme active.Get the active platform project. Les projets de plateforme sont les projets qui contiennent des ressources et code spécifique à la plateforme.Platform projects are the projects that contain platform-specific code and resources. La méthode suivante utilise le nouveau champ __VSHPROPID7 pour obtenir le projet pour la plateforme active.The following method uses the new field __VSHPROPID7 to get the active platform project.

    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 le ShowMessageBox (méthode), la légende du projet de plateforme active de sortie.In the ShowMessageBox method, output the caption of the active platform project.

    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");  
                return;  
            }  
        }  
        else  
            {  
                MessageBox.Show("No solution is open");  
                return;  
            }  
        }  
    
  12. Parcourir les projets de plateforme.Iterate through the platform projects. La méthode suivante obtient tous les projets (plate-forme) importation à partir du projet partagé.The following method gets all the importing (platform) projects from the shared project.

    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 universels C++ dans l’instance expérimentale, le code ci-dessus lève une exception.If the user has opened a C++ universal Windows app project in the experimental instance, the code above throws an exception. Il s'agit d'un problème connu.This is a known issue. Pour éviter l’exception, remplacez le foreach bloc ci-dessus avec les éléments suivants :To avoid the exception, replace the foreach block above with the following:

    var importingProjects = sharedAssetsProject.EnumImportingProjects();  
    for (int i = 0; i < importingProjects.Count; ++i)  
    {  
        yield return importingProjects[i];  
    }   
    
  13. Dans le ShowMessageBox (méthode), la légende de chaque projet de plateforme de sortie.In the ShowMessageBox method, output the caption of each platform project. Insérez le code suivant après la ligne qui génère la légende du projet de plateforme active.Insert the following code after the line that outputs the caption of the active platform project. Seuls les projets de plateforme qui sont chargés apparaissent dans cette liste.Only the platform projects that are loaded appear in this list.

    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. Modifier le projet pour la plateforme active.Change the active platform project. La méthode suivante définit le projet actif à l’aide de SetProperty.The following method sets the active project using SetProperty.

    private int SetActiveProjectContext(IVsHierarchy hierarchy, IVsHierarchy activeProjectContext)  
    {  
        return hierarchy.SetProperty((uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID7.VSHPROPID_SharedItemContextHierarchy, activeProjectContext);  
    }  
    
  15. Dans le ShowMessageBox (méthode), modifiez le projet pour la plateforme active.In the ShowMessageBox method, change the active platform project. Insérez ce code à l’intérieur de la foreach bloc.Insert this code inside the foreach block.

    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 maintenant. Appuyez sur F5 pour lancer l’instance expérimentale.Now try it out. Press F5 to launch the experimental instance. Créer un projet d’application hub universelle C# dans l’instance expérimentale (dans le nouveau projet boîte de dialogue, Visual C# / Windows / Windows 8 / universel / application Hub).Create a C# universal hub app project in the experimental instance (in the New Project dialog box, Visual C# / Windows / Windows 8 / Universal / Hub App). Une fois la solution est chargée, accédez à la outils menu et cliquez sur TestUniversalProject d’appeler, puis vérifiez le texte le sortie volet.After the solution is loaded, go to the Tools menu and click Invoke TestUniversalProject, and then check the text in the Output pane. Vous devez voir quelque chose comme suit :You should see something like the following:

    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 plateformeManage the shared items in the platform project

  1. Rechercher les éléments partagés dans le projet de plateforme.Find the shared items in the platform project. Les éléments dans le projet partagé apparaissent dans le projet pour la plateforme en tant qu’éléments partagés.The items in the shared project appear in the platform project as shared items. Vous ne pouvez pas afficher dans le l’Explorateur de solutions, mais vous pouvez parcourir la hiérarchie de projet pour les retrouver.You can't see them in the Solution Explorer, but you can walk the project hierarchy to find them. La méthode suivante présente la hiérarchie et collecte tous les éléments partagés.The following method walks the hierarchy and collects all the shared items. La légende de chaque élément, la sortie si vous le souhaitez.It optionally outputs the caption of each item,. Les éléments partagés sont identifiés par la nouvelle propriété __VSHPROPID7.The shared items are identified by the new property __VSHPROPID7.

    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 le ShowMessageBox (méthode), ajoutez le code suivant pour parcourir les éléments de hiérarchie de projet de plateforme.In the ShowMessageBox method, add the following code to walk the platform project hierarchy items. Insérez-le dans le foreach bloc.Insert it inside the foreach block.

    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. Lire les éléments partagés.Read the shared items. Les éléments partagés s’affichent dans le projet pour la plateforme en tant que fichiers liés masqués, et vous pouvez lire toutes les propriétés en tant que fichiers liés ordinaires.The shared items appear in the platform project as hidden linked files, and you can read all the properties as ordinary linked files. Le code suivant lit le chemin d’accès complet du premier élément partagé.The following code reads the full path of the first shared item.

    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 maintenant. Appuyez sur F5 pour lancer l’instance expérimentale.Now try it out. Press F5 to launch the experimental instance. Créer un projet d’application hub universelle C# dans l’instance expérimentale (dans le nouveau projet boîte de dialogue, Visual C# / Windows / Windows 8 / universel / application Hub) accédez à la outils menu et cliquez sur TestUniversalProject d’appeler, puis vérifiez le texte le sortie volet.Create a C# universal hub app project in the experimental instance (in the New Project dialog box, Visual C# / Windows / Windows 8 / Universal / Hub App) go to the Tools menu and click Invoke TestUniversalProject, and then check the text in the Output pane. Vous devez voir quelque chose comme suit :You should see something like the following:

    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 des modifications dans les projets de plateforme et de projets partagésDetecting changes in platform projects and shared projects

  1. Vous pouvez utiliser des événements de hiérarchie et de projet pour détecter des modifications dans les projets partagés, comme vous le faites pour les projets de plateforme.You can use hierarchy and project events to detect changes in shared projects, just as you can for platform projects. Toutefois, les éléments de projet dans le projet partagé ne sont pas visibles, ce qui signifie que certains événements ne se déclenchent pas lorsque des éléments de projet partagé sont modifiées.However, the project items in the shared project are not visible, which means that certain events do not fire when shared project items are changed.

    Examinons la séquence des événements lorsqu’un fichier dans un projet est renommé.Consider the sequence of events when a file in a project is renamed:

    1. Le nom de fichier est modifié sur le disque.The file name is changed on disk.

    2. Le fichier projet est mis à jour pour inclure le nouveau nom du fichier.The project file is updated to include the new name of the file.

      Événements de la hiérarchie (par exemple, IVsHierarchyEvents) généralement le suivi des modifications affichées dans l’interface utilisateur, comme dans le l’Explorateur de solutions.Hierarchy events (for example, IVsHierarchyEvents) generally track the changes displayed in the UI, as in the Solution Explorer. Événements de prendre en compte une opération de changement de nom de fichier se compose d’une suppression de fichiers, puis un ajout de fichier.Hierarchy events consider a file rename operation to consist of a file deletion and then a file addition. Toutefois, lorsque les éléments invisibles sont modifiés, le système d’événements hiérarchie déclenche un OnItemDeleted événements mais pas une OnItemAdded événement.However, when invisible items are changed, the hierarchy event system fires an OnItemDeleted event but not an OnItemAdded event. Par conséquent, si vous renommez un fichier dans un projet de plateforme, vous obtenez deux OnItemDeleted et OnItemAdded, mais si vous renommez un fichier dans un projet partagé, vous obtenez uniquement OnItemDeleted.Therefore, if you rename a file in a platform project, you get both OnItemDeleted and OnItemAdded, but if you rename a file in a shared project, you get only OnItemDeleted.

      Pour effectuer le suivi des modifications dans les éléments de projet, vous pouvez gérer les événements d’élément de projet DTE (ceux trouvés dans ProjectItemsEventsClass).To track changes in project items, you can handle DTE project item events (the ones found in ProjectItemsEventsClass). Toutefois, si vous gérez un grand nombre d’événements, vous pouvez obtenir de meilleures performances, la gestion des événements dans IVsTrackProjectDocuments2.However, if you are handling large numbers of events, you can get better performance handling the events in IVsTrackProjectDocuments2. Dans cette procédure pas à pas, nous affichons uniquement les événements de la hiérarchie et les événements DTE.In this walkthrough we show only the hierarchy events and the DTE events. Dans cette procédure vous ajoutez un écouteur d’événements à un projet partagé et un projet de plateforme.In this procedure you add an event listener to a shared project and a platform project. Ensuite, lorsque vous renommez un fichier dans un projet partagé et un autre dans un projet de plateforme, vous pouvez voir les événements qui sont déclenchés pour chaque opération de changement de nom.Then, when you rename one file in a shared project and another file in a platform project, you can see the events that are fired for each rename operation.

      Dans cette procédure vous ajoutez un écouteur d’événements à un projet partagé et un projet de plateforme.In this procedure you add an event listener to a shared project and a platform project. Ensuite, lorsque vous renommez un fichier dans un projet partagé et un autre dans un projet de plateforme, vous pouvez voir les événements qui sont déclenchés pour chaque opération de changement de nom.Then, when you rename one file in a shared project and another file in a platform project, you can see the events that are fired for each rename operation.

  2. Ajouter un écouteur d’événements.Add an event listener. Ajouter un nouveau fichier de classe au projet et appelez-le HierarchyEventListener.cs.Add a new class file to the project and call it HierarchyEventListener.cs.

  3. Ouvrez le fichier HierarchyEventListener.cs et ajoutez le code suivant à l’aide des instructions :Open the HierarchyEventListener.cs file and add the following using statements:

    using Microsoft.VisualStudio.Shell.Interop;  
    using Microsoft.VisualStudio;  
    using System.IO;  
    
  4. Avoir le HierarchyEventListener mettre en œuvre de la classe IVsHierarchyEvents:Have the HierarchyEventListener class implement IVsHierarchyEvents:

    class HierarchyEventListener : IVsHierarchyEvents  
    { }  
    
  5. Implémenter les membres de IVsHierarchyEvents, comme dans le code ci-dessous.Implement the members of IVsHierarchyEvents, as in the code below.

    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 DTE ItemRenamed, qui se produit chaque fois qu’un élément de projet est renommé.In the same class add another event handler for the DTE event ItemRenamed, which occurs whenever a project item is renamed.

    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 pour les événements de la hiérarchie.Sign up for the hierarchy events. Vous devez inscrire séparément pour chaque projet que vous effectuez le suivi.You need to sign up separately for every project you are tracking. Ajoutez le code suivant dans ShowMessageBox, une pour le projet partagé et l’autre pour un des projets de plateforme.Add the following code in ShowMessageBox, one for the shared project, and the other for one of the platform projects.

    // 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. S’inscrire pour l’événement d’élément de projet DTE ItemRenamed.Sign up for the DTE project item event ItemRenamed. Ajoutez le code suivant, une fois que vous raccordez le deuxième port d’écoute.Add the following code after you hook up the second listener.

    // hook up DTE events for project items  
    Events2 dteEvents = (Events2)dte.Events;  
    dteEvents.ProjectItemsEvents.ItemRenamed += listener1.OnItemRenamed;  
    
  9. Modifier l’élément partagé.Modify the shared item. 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.You can't modify shared items in a platform project; instead, you must modify them in the shared project that is the actual owner of these items. Vous pouvez obtenir l’ID d’élément correspondant dans le projet partagé avec IsDocumentInProject, en lui donnant un chemin d’accès complet de l’élément partagé.You can get the corresponding item ID in the shared project with IsDocumentInProject, giving it the shared item's full path. Vous pouvez ensuite modifier l’élément partagé.Then you can modify the shared item. La modification est propagée vers les projets de plateforme.The change is propagated to the platform projects.

    Important

    Vous devez rechercher ou non un élément de projet est un élément partagé avant de le modifier.You should find out whether or not a project item is a shared item before modifying it.

    La méthode suivante modifie le nom d’un fichier d’élément de projet.The following method modifies the name of a project item file.

    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 une fois tous les autres codes de ShowMessageBox pour modifier le nom de fichier l’élément dans le projet partagé.Call this method after all the other code in ShowMessageBox to modify the file name the item in the shared project. Insérez ce après le code qui obtient le chemin d’accès complet de l’élément dans le projet partagé.Insert this after the code that gets the full path of the item in the shared project.

    // 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.Build and run the project. Créer une application hub universelle C# dans l’instance expérimentale, accédez à la outils menu et cliquez sur TestUniversalProject d’appeleret vérifiez le texte dans le volet de sortie générale.Create a C# universal hub app in the experimental instance, go to the Tools menu and click Invoke TestUniversalProject, and check the text in the general output pane. Le nom du premier élément dans le partage de projet (nous espérons qu’il soit le fichier App.xaml) doit être modifié, et vous devez voir que la ItemRenamed événement a été déclenché.The name of the first item in the shared project (we expect it to be the App.xaml file) should be changed, and you should see that the ItemRenamed event has fired. Dans ce cas, étant donné que renommer App.xaml provoque App.xaml.cs à renommer ainsi, vous devez voir les quatre événements (deux pour chaque projet de plateforme).In this case, since renaming App.xaml causes App.xaml.cs to be renamed as well, you should see four events (two for each platform project). (Les événements DTE ne suivent pas les éléments dans le projet partagé.) Vous devez voir deux OnItemDeleted événements (une pour chacun des projets de plateforme), mais aucun OnItemAdded événements.(DTE events do not track the items in the shared project.) You should see two OnItemDeleted events (one for each of platform projects), but no OnItemAdded events.

  12. Maintenant essayer de renommer un fichier dans un projet de plateforme, et vous pouvez voir la différence dans les événements qui sont déclenchées.Now try renaming a file in a platform project, and you can see the difference in the events that get fired. Ajoutez le code suivant dans ShowMessageBox après l’appel à ModifyFileName.Add the following code in ShowMessageBox after the call to 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.Build and run the project. Créer un projet c# universel dans l’instance expérimentale, accédez à la outils menu et cliquez sur TestUniversalProject d’appeleret vérifiez le texte dans le volet de sortie générale.Create a C# Universal Project in the experimental instance, go to the Tools menu and click Invoke TestUniversalProject, and check the text in the general output pane. Après avoir renommé le fichier dans le projet de plateforme, vous devez voir les deux une OnItemAdded événement et un OnItemDeleted événement.After the file in the platform project is renamed, you should see both an OnItemAdded event and an OnItemDeleted event. Parce que la modification du fichier à l’origine aucun autre fichier à modifier dans la mesure où les modifications apportées aux éléments dans un projet de plateforme n’obtenir propagées n’importe où, il est donc seulement chacune de ces événements.Since changing the file caused no other files to be changed, and since changes to items in a platform project don't get propagated anywhere, there is only one each of these events.