Az alkalmazás kiterjesztése szolgáltatásokkal, bővítményekkel és csomagokkal

Windows számos olyan technológiát biztosít, amelyek lehetővé teszik, hogy az alkalmazás funkciókat biztosítson más alkalmazások számára, vagy külső bővítményeket használjon fel. Ez a cikk összehasonlítja Windows App SDK asztali alkalmazásokhoz elérhető bővíthetőségi lehetőségeket.

Bővíthetőségi lehetőségek áttekintése

Technológia Description Csomagazonosító szükséges Operációs rendszer minimális száma
App services Kérelmek és válaszok közötti kommunikáció az alkalmazások között a AppServiceConnection Igen Windows 10 1607
Alkalmazásbővítmények Beépülőmodul-modell – a gazdagépalkalmazás a bővítménycsomagokban lévő tartalmat találja meg Igen Windows 10 1607
Csomagbővítmények Szélesebb csomagszintű bővíthetőség a(z) uap17:PackageExtension révén Igen Windows 11
Választható csomagok További tartalomcsomagok, amelyek kiegészítik a főalkalmazást Igen Windows 10 1709
Erőforráscsomagok Nyelvi, skálázási és akadálymentességi eszközök piac szerint elválasztva Igen Windows 10

A megfelelő technológia kiválasztása

Használjon alkalmazásszolgáltatásokat, amikor

  • Kétirányú kommunikációra van szükség a különálló alkalmazások között.
  • A fogyasztói alkalmazás kérést küld, és vár a válaszra.
  • Api-szerű felületet szeretne más alkalmazások számára is elérhetővé tenni.

Példa: Egy fordítási szolgáltatás, amelyet más alkalmazások meghívhatnak a szöveg fordítására.

Alkalmazásbővítmények használata, amikor

  • Az alkalmazásnak szüksége van egy beépülő modulmodellre, amelyben harmadik felek tartalmakat, témákat vagy bővítményeket biztosítanak.
  • A bővítmények futtatókörnyezetben találhatók a telepített csomagokból.
  • A bővítmények adatokat vagy konfigurációt biztosítanak, nem végrehajtható kódot (a kódfuttatásnak appszolgáltatásokat kell használnia).

Példa: Egy képszerkesztő, amely felderíti a telepített bővítménycsomagok szűrőcsomagjait.

Használjon csomagbővítményeket, amikor

  • A Windows 11 szélesebb csomagszintű bővíthetőségre van szüksége.
  • A bővítményeknek több csomagtartalomhoz kell hozzáférni, mint amennyit a PublicFolder modell megenged.

Választható csomagok használata, ha

  • További tartalommal (DLC, prémium funkciók) rendelkezik külön csomagokban.
  • A tartalmat ugyanaz a közzétevő szerkesztette.

Architektúraminták

Alkalmazásszolgáltatás bővítményfelderítéssel

Az alkalmazásbővítmények és az appszolgáltatások kombinálása teljes beépülő modularchitektúrához:

  1. A gazdaalkalmazás a telepített bővítmények felderítésére használja AppExtensionCatalog .
  2. Minden bővítmény deklarálja a képességeit leíró tulajdonságokat.
  3. Amikor a felhasználó aktivál egy bővítményt, a gazdaalkalmazás kétirányú kommunikáció céljából csatlakozik a bővítmény appszolgáltatásához.
┌─────────────────┐      ┌──────────────────┐
│   Host app       │      │  Extension app    │
│                  │      │                   │
│ AppExtension     │◄────►│ AppExtension      │
│   Catalog        │      │   declaration     │
│                  │      │                   │
│ AppService       │◄────►│ AppService        │
│   Connection     │      │   provider        │
└─────────────────┘      └──────────────────┘

Csak tartalombővítmény

Egyszerűbb forgatókönyvek esetén, ahol a bővítmények statikus tartalmakat (témákat, sablonokat, adatfájlokat) biztosítanak:

  1. A hostalkalmazás a AppExtensionCatalog segítségével fedezi fel a bővítményeket.
  2. Beolvassa a fájlokat a bővítményből PublicFolder.
  3. Nincs szükség app service-ra.

Különbségek az UWP bővíthetőségétől

Az itt ismertetett bővíthetőségi technológiák ugyanúgy működnek Windows App SDK asztali alkalmazásokban, mint az UWP-ben, egyetlen követelmény: AZ MSIX-csomag identitása. Minden bővíthetőségi funkció a deklarációk csomagjegyzékére és a csomagkatalógusra támaszkodik a felderítéshez.

Ha az asztali alkalmazás ki van csomagolva, nem használhatja ezeket a bővíthetőségi technológiákat. Fontolja meg az alternatív módszereket, például:

  • COM-alapú beépülő modulok
  • Fájlrendszeralapú bővítményfelderítés
  • Névvel ellátott adatcsatornák vagy más IPC-mechanizmusok

Fájlalapú beépülő modul felderítése csomagolatlan alkalmazásokhoz

Nem csomagolt WinUI 3-alkalmazásokhoz a .NET AssemblyLoadContext használatával megvalósíthat egy beépülőmodul-rendszert, amely egy ismert mappából tölt be bővítményeket:

public class PluginLoader
{
    private readonly string _pluginDirectory;

    public PluginLoader(string pluginDirectory)
    {
        _pluginDirectory = pluginDirectory;
    }

    public IEnumerable<T> LoadPlugins<T>() where T : class
    {
        if (!Directory.Exists(_pluginDirectory))
            yield break;

        foreach (var dll in Directory.GetFiles(_pluginDirectory, "*.dll"))
        {
            var context = new PluginLoadContext(dll);
            var assembly = context.LoadFromAssemblyPath(Path.GetFullPath(dll));

            foreach (var type in assembly.GetTypes()
                .Where(t => typeof(T).IsAssignableFrom(t) && !t.IsAbstract))
            {
                if (Activator.CreateInstance(type) is T plugin)
                    yield return plugin;
            }
        }
    }
}

// Custom AssemblyLoadContext to isolate plugin dependencies
public class PluginLoadContext : AssemblyLoadContext
{
    private readonly AssemblyDependencyResolver _resolver;

    public PluginLoadContext(string pluginPath) : base(isCollectible: true)
    {
        _resolver = new AssemblyDependencyResolver(pluginPath);
    }

    protected override Assembly? Load(AssemblyName assemblyName)
    {
        var path = _resolver.ResolveAssemblyToPath(assemblyName);
        return path != null ? LoadFromAssemblyPath(path) : null;
    }
}

Warning

Biztonsági kockázatot jelent, ha a szerelvényeket ellenőrzés nélkül tölti be a lemezről. Éles környezetben betöltés előtt ellenőrizze az összeállítások aláírásait (például az Authenticode-ot), korlátozza a bővítmények könyvtárának ACL-jogosultságait, és fontolja meg a bővítmények külön folyamatban, csökkentett jogosultságokkal történő futtatását.

Definiáljon egy megosztott interfészszerződést egy külön assemblyben, amelyre mind a gazdagép, mind a beépülő modulok hivatkoznak:

// Contoso.App.Contracts (shared assembly)
public interface IPluginExtension
{
    string Name { get; }
    string Description { get; }
    void Execute(IServiceProvider services);
}

Megjegyzés:

A(z) AssemblyLoadContext elemben a(z) isCollectible: true használatával lehetővé válik a beépülő modulok futásidőben történő eltávolítása. Ez a megközelítés elkerüli az asztali alkalmazásokban (felügyelt bővíthetőségi keretrendszer) előforduló verziószámozási problémákat MEF .

Kapcsolódó tartalom

  • Last updated on