Udostępnij za pośrednictwem

Zarządzanie projektami uniwersalnymi systemu Windows

  • Artykuł

Aplikacje uniwersalne systemu Windows to aplikacje przeznaczone zarówno dla systemów Windows 8.1, jak i Windows Telefon 8.1, dzięki czemu deweloperzy mogą używać kodu i innych zasobów na obu platformach. Udostępniony kod i zasoby są przechowywane w udostępnionym projekcie, podczas gdy kod i zasoby specyficzne dla platformy są przechowywane w osobnych projektach, jeden dla systemu Windows i drugi dla systemu Windows Telefon. Aby uzyskać więcej informacji na temat uniwersalnych aplikacji systemu Windows, zobacz Aplikacje uniwersalne systemu Windows. Rozszerzenia programu Visual Studio, które zarządzają projektami, powinny mieć świadomość, że projekty aplikacji uniwersalnych systemu Windows mają strukturę, która różni się od aplikacji jednoplatformowych. W tym przewodniku pokazano, jak nawigować po udostępnionym projekcie i zarządzać elementami udostępnionymi.

  1. Utwórz projekt VSIX języka C# o nazwie TestUniversalProject. (Plik>nowy>projekt, a następnie C#>Rozszerzalność>pakietu Visual Studio). Dodaj szablon elementu projektu Polecenia niestandardowego (na Eksplorator rozwiązań kliknij prawym przyciskiem myszy węzeł projektu i wybierz polecenie Dodaj>nowy element, a następnie przejdź do pozycji Rozszerzalność. Nadaj plikowi nazwę TestUniversalProject.

  2. Dodaj odwołanie do biblioteki Microsoft.VisualStudio.Shell.Interop.12.1.DesignTime.dll i Microsoft.VisualStudio.Shell.Interop.14.0.DesignTime.dll (w sekcji Rozszerzenia).

  3. Otwórz plik TestUniversalProject.cs i dodaj następujące using dyrektywy:

    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. TestUniversalProject W klasie dodaj pole prywatne wskazujące okno Dane wyjściowe.

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

  5. Ustaw odwołanie do okienka danych wyjściowych wewnątrz konstruktora 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. Usuń istniejący kod z ShowMessageBox metody :

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

  7. Pobierz obiekt DTE, którego użyjemy do kilku różnych celów w tym przewodniku. Upewnij się również, że rozwiązanie jest ładowane po kliknięciu przycisku menu.

    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. Znajdź udostępniony projekt. Projekt udostępniony jest czystym kontenerem; nie tworzy ani nie generuje danych wyjściowych. Poniższa metoda znajduje pierwszy udostępniony projekt w rozwiązaniu, wyszukując IVsHierarchy obiekt, który ma udostępnioną funkcję projektu.

    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. W metodzie ShowMessageBox wyprowadź podpis (nazwę projektu wyświetlaną w Eksplorator rozwiązań) udostępnionego projektu.

    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. Uzyskaj aktywny projekt platformy. Projekty platformy to projekty zawierające kod i zasoby specyficzne dla platformy. Poniższa metoda używa nowego pola VSHPROPID_SharedItemContextHierarchy do pobrania aktywnego projektu platformy.

    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. W metodzie ShowMessageBox wyprowadź podpis aktywnego projektu platformy.

    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. Iterowanie za pośrednictwem projektów platformy. Poniższa metoda pobiera wszystkie projekty importowania (platformy) z udostępnionego projektu.

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

    Ważne

    Jeśli użytkownik otworzył projekt uniwersalnej aplikacji systemu Windows w języku C++ w wystąpieniu eksperymentalnym, powyższy kod zgłasza wyjątek. Jest to znany problem. Aby uniknąć wyjątku, zastąp foreach powyższy blok następującymi elementami:

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

  13. W metodzie ShowMessageBox wyprowadź podpis każdego projektu platformy. Wstaw następujący kod po wierszu, który zwraca podpis aktywnego projektu platformy. Na tej liście są wyświetlane tylko załadowane projekty platformy.

    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. Zmień aktywny projekt platformy. Poniższa metoda ustawia aktywny projekt przy użyciu polecenia SetProperty.

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

  15. W metodzie ShowMessageBox zmień aktywny projekt platformy. Wstaw ten kod wewnątrz foreach bloku.

    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. Teraz wypróbuj to. Naciśnij klawisz F5, aby uruchomić wystąpienie eksperymentalne. Utwórz projekt aplikacji uniwersalnego centrum języka C# w wystąpieniu eksperymentalnym (w oknie dialogowym Nowy projekt, aplikacja uniwersalna>systemu Windows 8 systemu Windows C#>Windows>8).> Po załadowaniu rozwiązania przejdź do menu Narzędzia i kliknij pozycję Wywołaj testUniversalProject, a następnie sprawdź tekst w okienku Dane wyjściowe . Powinna zostać wyświetlona zawartość podobna do tej:

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

Zarządzanie elementami udostępnionymi w projekcie platformy

  1. Znajdź elementy udostępnione w projekcie platformy. Elementy w projekcie udostępnionym są wyświetlane w projekcie platformy jako elementy udostępnione. Nie można ich zobaczyć w Eksplorator rozwiązań, ale możesz przejść do hierarchii projektów, aby je znaleźć. Poniższa metoda przeprowadzi hierarchię i zbierze wszystkie elementy udostępnione. Opcjonalnie zwraca podpis każdego elementu. Elementy udostępnione są identyfikowane przez nową właściwość 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. W metodzie ShowMessageBox dodaj następujący kod, aby przejść do elementów hierarchii projektu platformy. Wstaw go do foreach bloku.

    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. Odczytywanie elementów udostępnionych. Elementy udostępnione są wyświetlane w projekcie platformy jako ukryte połączone pliki i można odczytać wszystkie właściwości jako zwykłe połączone pliki. Poniższy kod odczytuje pełną ścieżkę pierwszego elementu udostępnionego.

    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. Teraz wypróbuj to. Naciśnij klawisz F5 , aby uruchomić wystąpienie eksperymentalne. Utwórz projekt aplikacji uniwersalnego centrum języka C# w wystąpieniu eksperymentalnym (w oknie dialogowym Nowy projekt visual C#>Aplikacja uniwersalna>centrum systemu Windows 8 systemu Windows>8>) przejdź do menu Narzędzia i kliknij polecenie Wywołaj testUniversalProject, a następnie sprawdź tekst w okienku Dane wyjściowe. Powinna zostać wyświetlona zawartość podobna do tej:

    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

Wykrywanie zmian w projektach platformy i projektach udostępnionych

  1. Zdarzenia hierarchii i projektu umożliwiają wykrywanie zmian w projektach udostępnionych, tak jak w przypadku projektów platformy. Jednak elementy projektu w udostępnionym projekcie nie są widoczne, co oznacza, że niektóre zdarzenia nie są wyzwalane po zmianie udostępnionych elementów projektu.

    Rozważ sekwencję zdarzeń, gdy nazwa pliku w projekcie zostanie zmieniona:

    1. Nazwa pliku jest zmieniana na dysku.

    2. Plik projektu jest aktualizowany w celu uwzględnienia nowej nazwy pliku.

      Zdarzenia hierarchii (na przykład IVsHierarchyEvents) zwykle śledzą zmiany wyświetlane w interfejsie użytkownika, jak w Eksplorator rozwiązań. Zdarzenia hierarchii uwzględniają operację zmiany nazwy pliku, która składa się z usunięcia pliku, a następnie dodawania pliku. Jednak w przypadku zmiany niewidocznych elementów system zdarzeń hierarchii uruchamia OnItemDeleted zdarzenie, ale nie OnItemAdded zdarzenie. W związku z tym jeśli zmienisz nazwę pliku w projekcie platformy, uzyskasz wartość i OnItemDeletedOnItemAdded, ale jeśli zmienisz nazwę pliku w udostępnionym projekcie, uzyskasz tylko OnItemDeletedwartość .

      Aby śledzić zmiany w elementach projektu, można obsługiwać zdarzenia elementu projektu DTE (te znalezione w pliku ProjectItemsEventsClass). Jeśli jednak obsługujesz dużą liczbę zdarzeń, możesz uzyskać lepszą wydajność obsługi zdarzeń w programie IVsTrackProjectDocuments2. W tym przewodniku pokażemy tylko zdarzenia hierarchii i zdarzenia DTE. W tej procedurze dodasz odbiornik zdarzeń do udostępnionego projektu i projektu platformy. Następnie podczas zmiany nazwy jednego pliku w udostępnionym projekcie i innego pliku w projekcie platformy można zobaczyć zdarzenia, które są wyzwalane dla każdej operacji zmiany nazwy.

      W tej procedurze dodasz odbiornik zdarzeń do udostępnionego projektu i projektu platformy. Następnie podczas zmiany nazwy jednego pliku w udostępnionym projekcie i innego pliku w projekcie platformy można zobaczyć zdarzenia, które są wyzwalane dla każdej operacji zmiany nazwy.

  2. Dodaj odbiornik zdarzeń. Dodaj nowy plik klasy do projektu i wywołaj go HierarchyEventListener.cs.

  3. Otwórz plik HierarchyEventListener.cs i dodaj następujące dyrektywy using:

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

  4. Zaimplementuj IVsHierarchyEventsklasę HierarchyEventListener :

    class HierarchyEventListener : IVsHierarchyEvents
{ }

  5. Zaimplementuj elementy członkowskie elementu IVsHierarchyEvents, tak jak w poniższym kodzie.

    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. W tej samej klasie dodaj kolejną procedurę obsługi zdarzeń dla zdarzenia ItemRenamedDTE , która występuje za każdym razem, gdy zmienia się nazwa elementu projektu.

    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. Zarejestruj się w celu uzyskania zdarzeń hierarchii. Musisz zarejestrować się oddzielnie dla każdego śledzonego projektu. Dodaj następujący kod w ShowMessageBoxpliku , jeden dla udostępnionego projektu, a drugi dla jednego z projektów platformy.

    // 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. Zarejestruj się, aby uzyskać zdarzenie ItemRenamedelementu projektu DTE . Dodaj następujący kod po podłączeniu drugiego odbiornika.

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

  9. Zmodyfikuj element udostępniony. Nie można modyfikować elementów udostępnionych w projekcie platformy; Zamiast tego należy zmodyfikować je w udostępnionym projekcie, który jest rzeczywistym właścicielem tych elementów. Możesz uzyskać odpowiedni identyfikator elementu w udostępnionym projekcie za pomocą IsDocumentInProjectpolecenia , nadając mu pełną ścieżkę elementu udostępnionego. Następnie możesz zmodyfikować element udostępniony. Zmiana jest propagowana do projektów platformy.

    Ważne

    Przed zmodyfikowaniem elementu projektu należy dowiedzieć się, czy element projektu jest elementem udostępnionym.

    Poniższa metoda modyfikuje nazwę pliku elementu projektu.

    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. Wywołaj tę metodę po wszystkim innym kodzie w pliku, ShowMessageBox aby zmodyfikować nazwę pliku w udostępnionym projekcie. Wstaw to po kodzie, który pobiera pełną ścieżkę elementu w udostępnionym projekcie.

    // 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. Skompiluj i uruchom projekt. Utwórz aplikację uniwersalną centrum języka C# w wystąpieniu eksperymentalnym, przejdź do menu Narzędzia i kliknij pozycję Wywołaj testUniversalProject i sprawdź tekst w okienku danych wyjściowych ogólnych. Nazwa pierwszego elementu w projekcie udostępnionym (oczekujemy, że ItemRenamed będzie to plik App.xaml) powinna zostać zmieniona i powinna zostać wyświetlona wartość zdarzenia. W takim przypadku, ponieważ zmiana nazwy app.xaml powoduje, że nazwa pliku App.xaml.cs również powinna zostać zmieniona, powinny zostać wyświetlone cztery zdarzenia (dwa dla każdego projektu platformy). (Zdarzenia DTE nie śledzą elementów w udostępnionym projekcie). Powinny zostać wyświetlone dwa OnItemDeleted zdarzenia (jedno dla każdego projektu platformy), ale nie ma zdarzeń OnItemAdded .

  12. Teraz spróbuj zmienić nazwę pliku w projekcie platformy i zobaczysz różnicę w zdarzeniach, które są wyzwalane. Dodaj następujący kod po ShowMessageBox wywołaniu metody .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. Skompiluj i uruchom projekt. Utwórz projekt uniwersalny języka C# w wystąpieniu eksperymentalnym, przejdź do menu Narzędzia i kliknij pozycję Wywołaj testUniversalProject, a następnie sprawdź tekst w okienku danych wyjściowych ogólnych. Po zmianie nazwy pliku w projekcie platformy powinien zostać wyświetlony zarówno OnItemAdded zdarzenie, jak i OnItemDeleted zdarzenie. Ponieważ zmiana pliku nie spowodowała zmiany innych plików, a zmiany elementów w projekcie platformy nie są propagowane w dowolnym miejscu, istnieje tylko jeden z tych zdarzeń.