Delen via

Universele Windows-projecten beheren

Universele Windows-apps zijn apps die gericht zijn op zowel Windows 8.1 als Windows Phone 8.1, zodat ontwikkelaars code en andere assets op beide platforms kunnen gebruiken. De gedeelde code en resources worden bewaard in een gedeeld project, terwijl de platformspecifieke code en resources in afzonderlijke projecten worden bewaard, één voor Windows en de andere voor Windows Phone. Zie Universele Windows-apps voor meer informatie over universele Windows-apps. Visual Studio-extensies die projecten beheren, moeten zich ervan bewust zijn dat universele Windows-app-projecten een structuur hebben die verschilt van apps met één platform. In dit overzicht ziet u hoe u door het gedeelde project navigeert en de gedeelde items beheert.

  1. Maak een C# VSIX-project met de naam TestUniversalProject. (Bestand>Nieuw>Project en vervolgens C#>Uitbreidbaarheid>Visual Studio Package). Voeg een projectitemsjabloon voor aangepaste opdrachten toe (klik in Solution Explorer met de rechtermuisknop op het projectknooppunt en selecteerNieuw item> en ga vervolgens naar Uitbreidbaarheid). Geef het bestand de naam TestUniversalProject.

  2. Voeg een verwijzing toe naar Microsoft.VisualStudio.Shell.Interop.12.1.DesignTime.dll en Microsoft.VisualStudio.Shell.Interop.14.0.DesignTime.dll (in de sectie Extensies ).

  3. Open TestUniversalProject.cs en voeg de volgende using instructies toe:

    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. Voeg in de TestUniversalProject klasse een privéveld toe dat verwijst naar het venster Uitvoer .

    public sealed class TestUniversalProject
{
    IVsOutputWindowPane output;
. . .
}

  5. Stel de verwijzing naar het uitvoervenster in testUniversalProject-constructor in:

    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. Verwijder de bestaande code uit de ShowMessageBox methode:

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

  7. Haal het DTE-object op, dat we voor verschillende doeleinden in dit scenario gaan gebruiken. Zorg er ook voor dat een oplossing wordt geladen wanneer op de menuknop wordt geklikt.

    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. Zoek het gedeelde project. Het gedeelde project is een pure container; het bouwt of produceert geen uitvoer. Met de volgende methode wordt het eerste gedeelde project in de oplossing gevonden door te zoeken naar het IVsHierarchy object met de mogelijkheid van het gedeelde project.

    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. Voer in de ShowMessageBox methode het bijschrift uit (de projectnaam die wordt weergegeven in Solution Explorer) van het gedeelde 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. Haal het actieve platformproject op. Platformprojecten zijn de projecten die platformspecifieke code en resources bevatten. De volgende methode gebruikt het nieuwe veld VSHPROPID_SharedItemContextHierarchy om het actieve platformproject op te halen.

    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. Voer in de ShowMessageBox methode het bijschrift van het actieve platformproject uit.

    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. Doorloop de platformprojecten. Met de volgende methode worden alle importprojecten (platform) opgehaald uit het gedeelde 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;
        }
    }
}

    Belangrijk

    Als de gebruiker een universeel Windows-app-project voor C++ heeft geopend in het experimentele exemplaar, genereert de bovenstaande code een uitzondering. Dit is een bekend probleem. Vervang het foreach bovenstaande blok door het volgende om de uitzondering te voorkomen:

    var importingProjects = sharedAssetsProject.EnumImportingProjects();
for (int i = 0; i < importingProjects.Count; ++i)
{
    yield return importingProjects[i];
}

  13. Voer in de ShowMessageBox methode het bijschrift van elk platformproject uit. Voeg de volgende code in na de regel die het bijschrift van het actieve platformproject uitvoert. Alleen de platformprojecten die in deze lijst worden geladen, worden weergegeven.

    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. Het actieve platformproject wijzigen. Met de volgende methode wordt het actieve project ingesteld met behulp van SetProperty.

    private int SetActiveProjectContext(IVsHierarchy hierarchy, IVsHierarchy activeProjectContext)
{
    return hierarchy.SetProperty((uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID7.VSHPROPID_SharedItemContextHierarchy, activeProjectContext);
}

  15. Wijzig in de ShowMessageBox methode het actieve platformproject. Voeg deze code in het foreach blok in.

    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. Probeer het nu eens. Druk op F5 om het experimentele exemplaar te starten. Maak een C# universal hub-app-project in het experimentele exemplaar (in het dialoogvenster Nieuw project, Visual C#>Windows>Windows 8>Universal>Hub App). Nadat de oplossing is geladen, gaat u naar het menu Extra en klikt u op TestUniversalProject aanroepen en controleert u de tekst in het deelvenster Uitvoer . U zou iets als het volgende moeten zien:

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

De gedeelde items in het platformproject beheren

  1. Zoek de gedeelde items in het platformproject. De items in het gedeelde project worden in het platformproject weergegeven als gedeelde items. U kunt ze niet zien in Solution Explorer, maar u kunt de projecthiërarchie doorlopen om ze te vinden. Met de volgende methode wordt de hiërarchie doorlopen en worden alle gedeelde items verzameld. Optioneel wordt het bijschrift van elk item weergegeven. De gedeelde items worden geïdentificeerd door de nieuwe eigenschap 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. Voeg in de ShowMessageBox methode de volgende code toe om de projecthiërarchie-items van het platform te doorlopen. Voeg het in het foreach blok in.

    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. Lees de gedeelde items. De gedeelde items worden in het platformproject weergegeven als verborgen gekoppelde bestanden en u kunt alle eigenschappen lezen als gewone gekoppelde bestanden. Met de volgende code wordt het volledige pad van het eerste gedeelde item gelezen.

    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. Probeer het nu eens. Druk op F5 om het experimentele exemplaar te starten. Maak een C# universal hub-app-project in het experimentele exemplaar (in het dialoogvenster Nieuw project , Visual C#>Windows>8>Universal>Hub App) ga naar het menu Extra en klik op TestUniversalProject aanroepen en controleer vervolgens de tekst in het deelvenster Uitvoer . U zou iets als het volgende moeten zien:

    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

Wijzigingen in platformprojecten en gedeelde projecten detecteren

  1. U kunt hiërarchie- en projectgebeurtenissen gebruiken om wijzigingen in gedeelde projecten te detecteren, net zoals voor platformprojecten. De projectitems in het gedeelde project zijn echter niet zichtbaar, wat betekent dat bepaalde gebeurtenissen niet worden geactiveerd wanneer gedeelde projectitems worden gewijzigd.

    Houd rekening met de volgorde van gebeurtenissen wanneer de naam van een bestand in een project wordt gewijzigd:

    1. De bestandsnaam wordt op schijf gewijzigd.

    2. Het projectbestand wordt bijgewerkt met de nieuwe naam van het bestand.

      Hiërarchiegebeurtenissen (bijvoorbeeld IVsHierarchyEvents) houden doorgaans de wijzigingen bij die worden weergegeven in de gebruikersinterface, zoals in Solution Explorer. Hiërarchiegebeurtenissen beschouwen een bewerking voor het wijzigen van de naam van een bestand om te bestaan uit het verwijderen van bestanden en vervolgens een toevoeging van een bestand. Wanneer onzichtbare items echter worden gewijzigd, wordt een OnItemDeleted gebeurtenis door het hiërarchiegebeurtenissysteem geactiveerd, maar geen OnItemAdded gebeurtenis. Dus als u de naam van een bestand in een platformproject wijzigt, krijgt u beide OnItemDeleted en OnItemAdded, maar als u de naam van een bestand in een gedeeld project wijzigt, krijgt u alleen OnItemDeleted.

      Als u wijzigingen in projectitems wilt bijhouden, kunt u gebeurtenissen voor DTE-projectitems verwerken (de gebeurtenissen in ProjectItemsEventsClass). Als u echter grote aantallen gebeurtenissen verwerkt, kunt u betere prestaties krijgen bij het verwerken van de gebeurtenissen in IVsTrackProjectDocuments2. In dit scenario laten we alleen de hiërarchiegebeurtenissen en de DTE-gebeurtenissen zien. In deze procedure voegt u een gebeurtenislistener toe aan een gedeeld project en een platformproject. Wanneer u vervolgens de naam van een bestand in een gedeeld project en een ander bestand in een platformproject wijzigt, ziet u de gebeurtenissen die worden geactiveerd voor elke naamswijzigingsbewerking.

      In deze procedure voegt u een gebeurtenislistener toe aan een gedeeld project en een platformproject. Wanneer u vervolgens de naam van een bestand in een gedeeld project en een ander bestand in een platformproject wijzigt, ziet u de gebeurtenissen die worden geactiveerd voor elke naamswijzigingsbewerking.

  2. Voeg een eventlistener toe. Voeg een nieuw klassebestand toe aan het project en noem het HierarchyEventListener.cs.

  3. Open het bestand HierarchyEventListener.cs en voeg het volgende toe met behulp van instructies:

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

  4. Laat de HierarchyEventListener klasse IVsHierarchyEvents implementeren.

    class HierarchyEventListener : IVsHierarchyEvents
{ }

  5. Implementeer de leden van IVsHierarchyEvents, zoals in de onderstaande code.

    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. Voeg in dezelfde klasse een andere gebeurtenishandler toe voor de DTE-gebeurtenis ItemRenamed, die plaatsvindt wanneer de naam van een projectitem wordt gewijzigd.

    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. Meld u aan voor de hiërarchiegebeurtenissen. U moet zich afzonderlijk registreren voor elk project dat u bijhoudt. Voeg de volgende code toe in ShowMessageBox, een voor het gedeelde project en de andere voor een van de platformprojecten.

    // 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. Meld u aan voor de DTE-projectitem-gebeurtenis ItemRenamed. Voeg de volgende code toe nadat u de tweede listener hebt gekoppeld.

    // hook up DTE events for project items
Events2 dteEvents = (Events2)dte.Events;
dteEvents.ProjectItemsEvents.ItemRenamed += listener1.OnItemRenamed;

  9. Wijzig het gedeelde item. U kunt gedeelde items in een platformproject niet wijzigen. In plaats daarvan moet u deze wijzigen in het gedeelde project dat de werkelijke eigenaar van deze items is. U kunt de bijbehorende item-id in het gedeelde project ophalen, IsDocumentInProjectwaardoor het volledige pad van het gedeelde item wordt weergegeven. Vervolgens kunt u het gedeelde item wijzigen. De wijziging wordt doorgegeven aan de platformprojecten.

    Belangrijk

    U moet nagaan of een projectitem een gedeeld item is voordat u het wijzigt.

    Met de volgende methode wordt de naam van een projectitembestand gewijzigd.

    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. Roep deze methode na alle andere code ShowMessageBox aan om de bestandsnaam van het item in het gedeelde project te wijzigen. Voeg dit in na de code die het volledige pad van het item in het gedeelde project ophaalt.

    // 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. Bouw het project en voer het uit. Maak een universele C#-hub-app in het experimentele exemplaar, ga naar het menu Extra en klik op TestUniversalProject aanroepen en controleer de tekst in het deelvenster algemene uitvoer. De naam van het eerste item in het gedeelde project (we verwachten dat het het App.xaml-bestand is) moet worden gewijzigd en u ziet dat de ItemRenamed gebeurtenis is geactiveerd. Omdat de naam van App.xaml in dit geval App.xaml.cs wordt gewijzigd, ziet u ook vier gebeurtenissen (twee voor elk platformproject). (DTE-gebeurtenissen houden de items in het gedeelde project niet bij.) U ziet twee OnItemDeleted gebeurtenissen (één voor elk van platformprojecten), maar geen OnItemAdded gebeurtenissen.

  12. Probeer nu de naam van een bestand in een platformproject te wijzigen en u kunt het verschil zien in de gebeurtenissen die worden geactiveerd. Voeg de volgende code toe ShowMessageBox na de aanroep naar 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. Bouw het project en voer het uit. Maak een C# Universeel project in het experimentele exemplaar, ga naar het menu Extra en klik op TestUniversalProject aanroepen en controleer de tekst in het algemene uitvoervenster. Nadat de naam van het bestand in het platformproject is gewijzigd, ziet u zowel een OnItemAdded gebeurtenis als een OnItemDeleted gebeurtenis. Omdat het wijzigen van het bestand ertoe heeft geleid dat er geen andere bestanden worden gewijzigd en omdat wijzigingen in items in een platformproject nergens worden doorgegeven, is er slechts één van deze gebeurtenissen.

  • Last updated on