Gérer les projets Windows universels

Article
10/10/2023

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.

Naviguer dans le projet partagé

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.
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 ).

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;

Dans la TestUniversalProject classe, ajoutez un champ privé pointant vers la fenêtre Sortie .
```
public sealed class TestUniversalProject
{
    IVsOutputWindowPane output;
. . .
}
```

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

Supprimez le code existant de la ShowMessageBox méthode :

private void ShowMessageBox(object sender, EventArgs e)
{
}

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

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

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

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

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

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

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

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

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');

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

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

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

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));
```

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

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.
Ajoutez un écouteur d’événements. Ajoutez un nouveau fichier de classe au projet et appelez-le HierarchyEventListener.cs.

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

using Microsoft.VisualStudio.Shell.Interop;
using Microsoft.VisualStudio;
using System.IO;

Mettre en œuvre IVsHierarchyEventsla HierarchyEventListener classe :
```
class HierarchyEventListener : IVsHierarchyEvents
{ }
```

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

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

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

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;

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

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

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.

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

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.

Partager via

Gérer les projets Windows universels

Naviguer dans le projet partagé

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

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

Ressources supplémentaires