Integracja spakowanej aplikacji komputerowej z Eksploratorem plików

Niektóre aplikacje systemu Windows definiują rozszerzenia Eksploratora plików, które dodają wpisy menu kontekstowego, które umożliwiają klientom wykonywanie opcji związanych z aplikacją. Starsze technologie wdrażania aplikacji systemu Windows, takie jak MSI i ClickOnce, definiują rozszerzenia Eksploratora plików za pośrednictwem rejestru. Rejestr zawiera serię gałęzi, które kontrolują rozszerzenia Eksploratora plików i inne typy rozszerzeń powłoki systemu. Te instalatory zazwyczaj tworzą serię kluczy rejestru, aby skonfigurować różne elementy do uwzględnienia w menu kontekstowym.

Jeśli spakujesz aplikację systemu Windows przy użyciu pliku MSIX, rejestr jest zwirtualizowany i dlatego aplikacja nie może zarejestrować rozszerzeń Eksploratora plików za pośrednictwem rejestru. Zamiast tego należy zdefiniować rozszerzenia Eksploratora plików za pomocą rozszerzeń pakietów zdefiniowanych w manifeście pakietu. W tym artykule opisano kilka sposobów, aby to zrobić.

Kompletny przykładowy kod używany w tym artykule znajdziesz na GitHubie.

Dodawanie wpisu menu kontekstowego obsługującego parametry uruchamiania

Jednym z najprostszych sposobów integracji z Eksploratorem plików jest zdefiniowanie rozszerzenia pakietu, które dodaje aplikację do listy dostępnych aplikacji w menu kontekstowym, gdy użytkownik kliknie prawym przyciskiem myszy określony typ pliku w Eksploratorze plików. Jeśli użytkownik otworzy aplikację, rozszerzenie może przekazać parametry do aplikacji.

Ten scenariusz ma kilka ograniczeń:

• Działa to tylko w połączeniu z funkcją skojarzenia typu pliku . W menu kontekstowym można wyświetlić dodatkowe opcje tylko dla typów plików skojarzonych z główną aplikacją (na przykład aplikacja obsługuje otwieranie pliku, klikając go dwukrotnie w Eksploratorze plików).
• Opcje w menu kontekstowym będą wyświetlane tylko wtedy, gdy aplikacja jest ustawiona jako domyślna dla tego typu pliku.
• Jedyną obsługiwaną akcją jest uruchomienie głównego pliku wykonywalnego aplikacji (czyli tego samego pliku wykonywalnego połączonego z wpisem menu Start). Jednak każda akcja może określać różne parametry, których można użyć, gdy aplikacje zaczynają rozumieć, która akcja wyzwoliła wykonywanie i wykonywać różne zadania.

Pomimo tych ograniczeń takie podejście jest wystarczające w przypadku wielu scenariuszy. Jeśli na przykład tworzysz edytor obrazów, możesz łatwo dodać wpis w menu kontekstowym, aby zmienić rozmiar obrazu, co spowoduje uruchomienie edytora obrazów bezpośrednio za pomocą kreatora w celu rozpoczęcia procesu zmiany rozmiaru.

Implementowanie wpisu menu kontekstowego

Aby obsłużyć ten scenariusz, dodaj element Extension z kategorią windows.fileTypeAssociation do manifestu pakietu. Ten element należy dodać jako element podrzędny elementu Extensions w elemecie Application.

W poniższym przykładzie pokazano rejestrację aplikacji, która umożliwia menu kontekstowe plików z .foo rozszerzeniem. W tym przykładzie określono rozszerzenie .foo, ponieważ jest to fikcyjne rozszerzenie, które zazwyczaj nie jest zarejestrowane w żadnej innej aplikacji na danym komputerze. Jeśli musisz zarządzać typem pliku, który może być już zajęty (na przykład .txt lub .jpg), pamiętaj, że nie zobaczysz tej opcji, dopóki Twoja aplikacja nie zostanie ustawiona jako domyślna dla tego typu pliku. Ten przykład jest fragmentem pliku Package.appxmanifest w powiązanym przykładzie na GitHubie.

<Extensions>
  <uap3:Extension Category="windows.fileTypeAssociation">
    <uap3:FileTypeAssociation Name="foo" Parameters="&quot;%1&quot;">
      <uap:SupportedFileTypes>
        <uap:FileType>.foo</uap:FileType>
      </uap:SupportedFileTypes>
      <uap2:SupportedVerbs>
        <uap3:Verb Id="Resize" Parameters="&quot;%1&quot; /p">Resize file</uap3:Verb>
      </uap2:SupportedVerbs>
    </uap3:FileTypeAssociation>
  </uap3:Extension>
</Extensions>

W tym przykładzie przyjęto założenie, że następujące przestrzenie nazw i aliasy są deklarowane w głównym elemencie <Package> w manifeście.

<Package
  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
  xmlns:uap2="http://schemas.microsoft.com/appx/manifest/uap/windows10/2"
  xmlns:uap3="http://schemas.microsoft.com/appx/manifest/uap/windows10/3"
  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
  IgnorableNamespaces="uap uap2 uap3 rescap">
  ...
</Package>

Element FileTypeAssociation kojarzy aplikację z typami plików, które mają być obsługiwane. Aby uzyskać więcej informacji, zobacz Kojarzenie spakowanej aplikacji z zestawem typów plików. Poniżej przedstawiono najważniejsze elementy związane z tym elementem.

Aby zdefiniować integrację menu kontekstowego, należy dodać także podrzędny element SupportedVerbs. Ten element zawiera jeden lub więcej elementów Czasownik definiujących opcje, które będą wyświetlane po kliknięciu prawym przyciskiem myszy na pliku z rozszerzeniem .foo w Eksploratorze plików. Aby uzyskać więcej informacji, zobacz Dodawanie opcji do menu kontekstowych plików, które mają określony typ pliku. Poniżej przedstawiono najważniejsze elementy związane z elementem czasownika .

Uzyskiwanie dostępu do parametrów uruchamiania w kodzie aplikacji

Sposób, w jaki aplikacja odbiera parametry, zależy od typu utworzonej aplikacji. Na przykład aplikacja WPF zwykle przetwarza args zdarzeń uruchamiania w metodzie OnStartup klasy App. Możesz sprawdzić, czy istnieją parametry uruchamiania i, na podstawie wyniku, podejmij najbardziej odpowiednią akcję (na przykład otwarcie określonego okna aplikacji zamiast głównego).

public partial class App : Application
{
    protected override void OnStartup(StartupEventArgs e)
    {
        if (e.Args.Contains("Resize"))
        {
            // Open a specific window of the app.
        }
        else
        {
            MainWindow main = new MainWindow();
            main.Show();
        }
    }
}

Poniższy zrzut ekranu przedstawia pozycję menu kontekstowego Zmień rozmiar pliku utworzoną przez poprzedni przykład.

Obsługa ogólnych plików lub folderów i wykonywanie złożonych zadań

Mimo że użycie rozszerzenia FileTypeAssociation w manifeście pakietu zgodnie z opisem w poprzedniej sekcji jest wystarczające w przypadku wielu scenariuszy, możesz stwierdzić, że jest ograniczające. Dwa największe wyzwania to:

• Można obsługiwać tylko skojarzone typy plików. Na przykład nie można obsłużyć folderu ogólnego.
• Aplikację można uruchomić tylko z serią parametrów. Nie można wykonywać zaawansowanych operacji, takich jak uruchamianie innego pliku wykonywalnego lub wykonywanie zadania bez otwierania głównej aplikacji.

Aby osiągnąć te cele, musisz stworzyć rozszerzenie powłoki, które oferuje bardziej zaawansowane metody integracji z Eksploratorem plików. W tym scenariuszu utworzysz bibliotekę DLL zawierającą wszystkie elementy wymagane do zarządzania menu kontekstowym pliku, w tym etykietą, ikoną, stanem i zadaniami do wykonania. Ponieważ ta funkcja jest implementowana w dll, możesz wykonać prawie wszystko, co można zrobić za pomocą normalnej aplikacji. Po zaimplementowaniu biblioteki DLL należy zarejestrować ją za pomocą rozszerzeń zdefiniowanych w manifeście pakietu.

Zaimplementuj rozszerzenie powłoki

Rozszerzenia powłoki są oparte na modelu obiektów COM (Component Object Model). Biblioteka DLL uwidacznia co najmniej jeden obiekt COM zarejestrowany w rejestrze systemowym. System Windows odnajduje te obiekty COM i integruje rozszerzenie z Eksploratorem plików. Ponieważ integrujesz kod z powłoką systemu Windows, wydajność i zużycie pamięci są ważne. W związku z tym tego tego rodzaju rozszerzenia są zwykle kompilowane przy użyciu języka C++.

Aby zapoznać się z przykładowym kodem ilustrującym sposób implementacji rozszerzeń powłoki, zobacz projekt ExplorerCommandVerb w powiązanym przykładzie na GitHub. Ten projekt jest oparty na tej próbce w przykładowych aplikacjach dla pulpitu Windows i zawiera kilka poprawek, dzięki którym próbka jest łatwiejsza w użyciu z najnowszymi wersjami programu Visual Studio.

Ten projekt zawiera wiele standardowego kodu do różnych zadań, takich jak dynamiczne a statyczne menu oraz ręczna rejestracja biblioteki DLL. Większość tego kodu nie jest potrzebna, jeśli pakujesz aplikację przy użyciu pliku MSIX, ponieważ obsługa tworzenia pakietów zajmie się tymi zadaniami. Plik ExplorerCommandVerb.cpp zawiera implementację menu kontekstowego i jest to główny plik kodu, na którym skupia się ten przewodnik.

Kluczowa funkcja to CExplorerCommandVerb::Invoke. Jest to funkcja wywoływana, gdy użytkownik kliknie wpis w menu kontekstowym. W tym przykładzie, aby zminimalizować wpływ na wydajność, operacja jest wykonywana w innym wątku, więc rzeczywiście znajdziesz właściwą implementację w CExplorerCommandVerb::_ThreadProc.

DWORD CExplorerCommandVerb::_ThreadProc()
{
	IShellItemArray* psia;
	HRESULT hr = CoGetInterfaceAndReleaseStream(_pstmShellItemArray, IID_PPV_ARGS(&psia));
	_pstmShellItemArray = NULL;
	if (SUCCEEDED(hr))
	{
		DWORD count;
		psia->GetCount(&count);

		IShellItem2* psi;
		HRESULT hr = GetItemAt(psia, 0, IID_PPV_ARGS(&psi));
		if (SUCCEEDED(hr))
		{
			PWSTR pszName;
			hr = psi->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, &pszName);
			if (SUCCEEDED(hr))
			{
				WCHAR szMsg[128];
				StringCchPrintf(szMsg, ARRAYSIZE(szMsg), L"%d item(s), first item is named %s", count, pszName);

				MessageBox(_hwnd, szMsg, L"ExplorerCommand Sample Verb", MB_OK);

				CoTaskMemFree(pszName);
			}

			psi->Release();
		}
		psia->Release();
	}

	return 0;
}

Gdy użytkownik kliknie prawym przyciskiem myszy plik lub folder, ta funkcja wyświetli pole komunikatu z pełną ścieżką wybranego pliku lub folderu. Jeśli chcesz dostosować rozszerzenie powłoki na inny sposób, możesz rozszerzyć następujące funkcje w przykładzie:

• Możesz zmienić funkcję GetTitle , aby dostosować etykietę wpisu w menu kontekstowym.
• Możesz zmienić funkcję GetIcon , aby dostosować ikonę wyświetlaną w pobliżu wpisu w menu kontekstowym.
• Możesz zmienić funkcję GetTooltip, aby dostosować etykietkę narzędzia wyświetlaną po umieszczeniu wskaźnika myszy na wpisie w menu kontekstowym.

Zarejestruj rozszerzenie powłoki

Ponieważ rozszerzenie powłoki jest oparte na modelu COM, biblioteka DLL implementacji musi być udostępniona jako serwer COM, aby system Windows mógł go zintegrować z Eksploratorem plików. Zazwyczaj odbywa się to przez przypisanie unikatowego identyfikatora (o nazwie CLSID) do serwera COM i zarejestrowanie go w określonej gałęzi rejestru systemowego. W projekcie ExplorerCommandVerb identyfikator CLSID rozszerzenia CExplorerCommandVerb jest zdefiniowany w pliku Dll.h .

class __declspec(uuid("CC19E147-7757-483C-B27F-3D81BCEB38FE")) CExplorerCommandVerb;

Podczas pakowania biblioteki DLL rozszerzenia powłoki w pakiecie MSIX stosuje się podobne podejście. Jednak identyfikator GUID musi być zarejestrowany wewnątrz manifestu pakietu zamiast rejestru, jak wyjaśniono tutaj.

W manifeście pakietu zacznij od dodania następujących przestrzeni nazw do elementu Package.

<Package
  xmlns:desktop="http://schemas.microsoft.com/appx/manifest/desktop/windows10"
  xmlns:desktop4="http://schemas.microsoft.com/appx/manifest/desktop/windows10/4"
  xmlns:desktop5="http://schemas.microsoft.com/appx/manifest/desktop/windows10/5"
  xmlns:com="http://schemas.microsoft.com/appx/manifest/com/windows10" 
  IgnorableNamespaces="desktop desktop4 desktop5 com">
    
    ...
</Package>

Aby zarejestrować identyfikator CLSID, dodaj com.Extension element z kategorią windows.comServer do manifestu pakietu. Ten element należy dodać jako element podrzędny elementu Extensions w elemecie Application. Ten przykład jest fragmentem pliku Package.appxmanifest w powiązanym przykładzie na GitHubie.

<com:Extension Category="windows.comServer">
  <com:ComServer>
    <com:SurrogateServer DisplayName="ContextMenuSample">
      <com:Class Id="CC19E147-7757-483C-B27F-3D81BCEB38FE" Path="ExplorerCommandVerb.dll" ThreadingModel="STA"/>
    </com:SurrogateServer>
  </com:ComServer>
</com:Extension>

W elemecie com:Class należy skonfigurować dwa atrybuty krytyczne.

Następnie dodaj kolejne rozszerzenie, które rejestruje menu kontekstowe pliku. W tym celu dodaj element desktop4:Extension z kategorią windows.fileExplorerContextMenus do manifestu pakietu. Ten element należy również dodać jako element podrzędny elementu Extensions w elemencie Application.

<desktop4:Extension Category="windows.fileExplorerContextMenus">
  <desktop4:FileExplorerContextMenus>
    <desktop5:ItemType Type="Directory">
      <desktop5:Verb Id="Command1" Clsid="CC19E147-7757-483C-B27F-3D81BCEB38FE" />
    </desktop5:ItemType>
  </desktop4:FileExplorerContextMenus>
</desktop4:Extension>

Istnieją dwa atrybuty krytyczne do skonfigurowania w ramach elementu desktop4:Extension .

Konfigurowanie biblioteki DLL w pakiecie

Dołącz bibliotekę DLL implementującą rozszerzenie powłoki (w tym przykładzie ExplorerCommandVerb.dll) do katalogu głównego pakietu MSIX. Jeśli używasz projektu Windows Application Packaging Project, najprostszym rozwiązaniem jest skopiowanie i wklejenie biblioteki DLL do projektu oraz upewnienie się, że opcja Kopiuj do katalogu wyjściowego we właściwościach pliku DLL jest ustawiona na Skopiuj, jeśli nowsze.

Aby upewnić się, że pakiet zawsze zawiera najnowszą wersję biblioteki DLL, możesz dodać do projektu rozszerzenia powłoki systemu zdarzenie po kompilacji, aby za każdym razem, gdy go skompilujesz, biblioteka DLL była kopiowana do projektu Windows Application Packaging.

Uruchom ponownie Eksploratora plików

Po zainstalowaniu pakietu rozszerzeń powłoki należy ponownie uruchomić Eksploratora plików, aby załadować rozszerzenie powłoki. Jest to ograniczenie rozszerzeń powłoki, które są wdrażane i rejestrowane za pośrednictwem pakietów MSIX.

Aby przetestować rozszerzenie powłoki, uruchom ponownie komputer lub uruchom ponownie proces explorer.exe przy użyciu Menedżera Zadań . Po wykonaniu tej czynności powinien być widoczny wpis w menu kontekstowym.

Po kliknięciu na to, wywołana zostanie funkcja CExplorerCommandVerb::_ThreadProc, aby wyświetlić okno komunikatu ze ścieżką wybranego folderu.