Condividi tramite

Cenni preliminari sui componenti aggiuntivi di WPF

  • Articolo

.NET Framework include un modello di componente aggiuntivo che gli sviluppatori possono usare per creare applicazioni che supportano l'estendibilità dei componenti aggiuntivi. Questo modello consente di creare componenti aggiuntivi che si integrano con le funzionalità dell'applicazione estendendole. In alcuni scenari, le applicazioni devono anche visualizzare le interfacce utente fornite dai componenti aggiuntivi. Questo argomento illustra in che modo WPF aumenta il modello di componente aggiuntivo .NET Framework per abilitare questi scenari, l'architettura sottostante, i relativi vantaggi e le relative limitazioni.

Prerequisiti

È necessaria la familiarità con il modello di componente aggiuntivo .NET Framework. Per altre informazioni, vedere Componenti aggiuntivi ed estendibilità.

Cenni preliminari sui componenti aggiuntivi

Per evitare le complessità legate alla ricompilazione e alla ridistribuzione di un'applicazione per incorporare nuove funzionalità, le applicazioni implementano meccanismi di estendibilità che consentono agli sviluppatori dell'applicazione e a quelli di terze parti di creare altre applicazioni che si integrano con esse. Il metodo più comune per supportare questo tipo di estendibilità consiste nell'usare i componenti aggiuntivi, noti anche come "plug-in". Di seguito sono riportati alcuni esempi di applicazioni reali che espongono l'estendibilità mediante componenti aggiuntivi:

  • Componenti aggiuntivi di Internet Explorer.

  • Plug-in di Windows Media Player.

  • Componenti aggiuntivi di Visual Studio.

Il modello di componente aggiuntivo di Windows Media Player, ad esempio, consente agli sviluppatori di terze parti di implementare "plug-in" che estendono Windows Media Player in diversi modi, come tramite la creazione di decodificatori e codificatori per formati multimediali non supportati a livello nativo da Windows Media Player (ad esempio DVD, MP3), effetti audio e interfacce. Ogni modello di componente aggiuntivo è creato per esporre funzionalità univoche di un'applicazione, anche se ci sono diversi comportamenti ed entità comuni a tutti i modelli.

Le tre entità principali delle soluzioni tipiche di estendibilità mediante componenti aggiuntivi sono contratti, componenti aggiuntivi e applicazioni host. I contratti definiscono la modalità di integrazione dei componenti aggiuntivi con le applicazioni host in due modi:

  • I componenti aggiuntivi si integrano con le funzionalità implementate dalle applicazioni host.

  • Le applicazioni host espongono funzionalità con cui i componenti aggiuntivi si integrano.

Per poter usare i componenti aggiuntivi, le applicazioni host devono trovarli e caricarli in fase di esecuzione. Di conseguenza, le applicazioni che supportano i componenti aggiuntivi hanno le ulteriori responsabilità seguenti:

  • Individuazione: trovare i componenti aggiuntivi conformi ai contratti supportati dalle applicazioni host.

  • Attivazione: caricare ed eseguire i componenti aggiuntivi e stabilire la comunicazione con essi.

  • Isolamento: usare i processi o i domini dell'applicazione per stabilire i limiti di isolamento che proteggono le applicazioni da potenziali problemi di sicurezza e di esecuzione relativi ai componenti aggiuntivi.

  • Comunicazione: consentire ai componenti aggiuntivi e alle applicazioni host di comunicare tra loro oltre i limiti di isolamento, mediante la chiamata a metodi e il passaggio di dati.

  • Gestione della durata: caricare e scaricare processi e domini dell'applicazione in modo netto e prevedibile (vedere Domini applicazione).

  • Controllo delle versioni: assicurare che le applicazioni host e i componenti aggiuntivi possano continuare a comunicare quando vengono create nuove versioni.

In definitiva, lo sviluppo di un modello di componente aggiuntivo affidabile è un'operazione tutt'altro che banale. Per questo motivo, .NET Framework fornisce un'infrastruttura per la creazione di modelli di componente aggiuntivo.

Nota

Per informazioni più dettagliate sui componenti aggiuntivi, vedere Componenti aggiuntivi ed estendibilità.

Cenni preliminari sul modello di componente aggiuntivo .NET Framework

Il modello di componente aggiuntivo .NET Framework, disponibile nello spazio dei System.AddIn nomi , contiene un set di tipi progettati per semplificare lo sviluppo dell'estendibilità del componente aggiuntivo. L'unità fondamentale del modello di componente aggiuntivo .NET Framework è il contratto, che definisce il modo in cui un'applicazione host e un componente aggiuntivo comunicano tra loro. Un contratto viene esposto a un'applicazione host usando una vista del contratto specifica dell'applicazione host. Analogamente, una vista del contratto specifica del componente aggiuntivo viene esposta al componente aggiuntivo. Un adattatore consente a un'applicazione host e a un componente aggiuntivo di comunicare tra le rispettive viste del contratto. Contratti, viste e adattatori vengono detti segmenti e un set di segmenti correlati costituisce una pipeline. Le pipeline sono la base su cui il modello di componente aggiuntivo .NET Framework supporta l'individuazione, l'attivazione, l'isolamento della sicurezza, l'isolamento dell'esecuzione (usando sia domini applicazione che processi), la comunicazione, la gestione della durata e il controllo delle versioni.

Questo supporto consente agli sviluppatori di creare componenti aggiuntivi che si integrano con le funzionalità di un'applicazione host. Tuttavia, alcuni scenari richiedono che le applicazioni host visualizzino le interfacce utente fornite dai componenti aggiuntivi. Poiché ogni tecnologia di presentazione in .NET Framework ha un proprio modello per l'implementazione delle interfacce utente, il modello di componente aggiuntivo .NET Framework non supporta alcuna tecnologia di presentazione specifica. WPF estende invece il modello di componente aggiuntivo .NET Framework con il supporto dell'interfaccia utente per i componenti aggiuntivi.

Componenti aggiuntivi WPF

WPF, in combinazione con il modello di componente aggiuntivo .NET Framework, consente di gestire un'ampia gamma di scenari che richiedono alle applicazioni host di visualizzare le interfacce utente dai componenti aggiuntivi. In particolare, questi scenari vengono gestiti da WPF con i due modelli di programmazione seguenti:

  1. Componente aggiuntivo che restituisce un'interfaccia utente. Un componente aggiuntivo restituisce un'interfaccia utente all'applicazione host tramite una chiamata al metodo, come definito dal contratto. Questo scenario viene usato nei casi seguenti:

    • L'aspetto di un'interfaccia utente restituita da un componente aggiuntivo dipende da dati o condizioni esistenti solo in fase di esecuzione, ad esempio report generati dinamicamente.

    • L'interfaccia utente per i servizi forniti da un componente aggiuntivo è diversa dall'interfaccia utente delle applicazioni host che possono usare il componente aggiuntivo.

    • Il componente aggiuntivo esegue principalmente un servizio per l'applicazione host e segnala lo stato all'applicazione host con un'interfaccia utente.

  2. Componente aggiuntivo che costituisce un'interfaccia utente. Un componente aggiuntivo è un'interfaccia utente, come definito dal contratto. Questo scenario viene usato nei casi seguenti:

    • Un componente aggiuntivo non fornisce alcun servizio eccetto la sua visualizzazione, come nel caso di un annuncio.

    • L'interfaccia utente per i servizi forniti da un componente aggiuntivo è comune a tutte le applicazioni host che possono usare tale componente aggiuntivo, ad esempio una calcolatrice o una selezione colori.

Questi scenari richiedono che gli oggetti dell'interfaccia utente possano essere passati tra l'applicazione host e i domini applicazione del componente aggiuntivo. Poiché il modello di componente aggiuntivo .NET Framework si basa sulla comunicazione remota per comunicare tra domini applicazione, gli oggetti passati tra di essi devono essere remotizzabili.

Un oggetto che può essere usato in remoto è un'istanza di una classe che soddisfa una o più delle condizioni seguenti:

Nota

Per altre informazioni sulla creazione di oggetti .NET Framework remotabili, vedere Creazione di oggetti remotizzabili.

I tipi di interfaccia utente WPF non sono remotizzabili. Per risolvere il problema, WPF estende il modello di componente aggiuntivo .NET Framework per consentire la visualizzazione dell'interfaccia utente WPF creata dai componenti aggiuntivi dalle applicazioni host. Questo supporto viene fornito da WPF da due tipi: l'interfaccia INativeHandleContract e due metodi statici implementati dalla FrameworkElementAdapters classe : ContractToViewAdapter e ViewToContractAdapter. A livello generale, questi tipi e metodi vengono usati nel modo seguente:

  1. WPF richiede che le interfacce utente fornite dai componenti aggiuntivi siano classi che derivano direttamente o indirettamente da FrameworkElement, ad esempio forme, controlli, controlli utente, pannelli di layout e pagine.

  2. Ovunque il contratto dichiari che un'interfaccia utente verrà passata tra il componente aggiuntivo e l'applicazione host, deve essere dichiarata come (non FrameworkElementun INativeHandleContract ). INativeHandleContract è una rappresentazione remota dell'interfaccia utente del componente aggiuntivo che può essere passata attraverso i limiti di isolamento.

  3. Prima di essere passato dal dominio dell'applicazione del componente aggiuntivo, un FrameworkElement oggetto viene incluso nel pacchetto come oggetto INativeHandleContract chiamando ViewToContractAdapter.

  4. Dopo essere stato passato al dominio applicazione dell'applicazione host, l'oggetto INativeHandleContract deve essere ripacchetto come oggetto FrameworkElement chiamando ContractToViewAdapter.

La modalità INativeHandleContractdi utilizzo di , ContractToViewAdaptere ViewToContractAdapter dipende dallo scenario specifico. Le sezioni seguenti forniscono informazioni dettagliate per ogni modello di programmazione.

Componente aggiuntivo che restituisce un'interfaccia utente

Affinché un componente aggiuntivo restituisca un'interfaccia utente a un'applicazione host, sono necessari gli elementi seguenti:

  1. È necessario creare l'applicazione host, il componente aggiuntivo e la pipeline, come descritto dalla documentazione relativa ai componenti aggiuntivi e all'estendibilità di .NET Framework.

  2. Il contratto deve implementare IContract e, per restituire un'interfaccia utente, il contratto deve dichiarare un metodo con un valore restituito di tipo INativeHandleContract.

  3. L'interfaccia utente passata tra il componente aggiuntivo e l'applicazione host deve derivare direttamente o indirettamente da FrameworkElement.

  4. L'interfaccia utente restituita dal componente aggiuntivo deve essere convertita da un FrameworkElement oggetto a un INativeHandleContract prima di superare il limite di isolamento.

  5. L'interfaccia utente restituita deve essere convertita da un INativeHandleContract oggetto a dopo FrameworkElement aver superato il limite di isolamento.

  6. L'applicazione host visualizza l'oggetto restituito FrameworkElement.

Per un esempio che illustra come implementare un componente aggiuntivo che restituisce un'interfaccia utente, vedere Creare un componente aggiuntivo che restituisce un'interfaccia utente.

Componente aggiuntivo che costituisce un'interfaccia utente

Quando un componente aggiuntivo è un'interfaccia utente, sono necessari gli elementi seguenti:

  1. È necessario creare l'applicazione host, il componente aggiuntivo e la pipeline, come descritto dalla documentazione relativa ai componenti aggiuntivi e all'estendibilità di .NET Framework.

  2. L'interfaccia del contratto per il componente aggiuntivo deve implementare INativeHandleContract.

  3. Il componente aggiuntivo passato all'applicazione host deve derivare direttamente o indirettamente da FrameworkElement.

  4. Il componente aggiuntivo deve essere convertito da un FrameworkElement oggetto a un INativeHandleContract prima di superare il limite di isolamento.

  5. Il componente aggiuntivo deve essere convertito da un INativeHandleContract oggetto a un FrameworkElement dopo aver superato il limite di isolamento.

  6. L'applicazione host visualizza l'oggetto restituito FrameworkElement.

Per un esempio che illustra come implementare un componente aggiuntivo che è un'interfaccia utente, vedere Creare un componente aggiuntivo che rappresenta un'interfaccia utente.

Restituzione di più interfacce utente da un componente aggiuntivo

I componenti aggiuntivi spesso forniscono più interfacce utente per la visualizzazione delle applicazioni host. Si consideri ad esempio un componente aggiuntivo che è un'interfaccia utente che fornisce anche informazioni sullo stato per l'applicazione host, anche come interfaccia utente. Un componente aggiuntivo di questo tipo può essere implementato usando una combinazione di tecniche dei modelli Componente aggiuntivo che restituisce un'interfaccia utente e Componente aggiuntivo che costituisce un'interfaccia utente.

Componenti aggiuntivi e applicazioni browser XAML

Negli esempi illustrati fino a questo momento l'applicazione host era un'applicazione autonoma installata. Tuttavia, le applicazioni browser XAML (XBAP) possono anche ospitare componenti aggiuntivi, anche se con i requisiti di compilazione e implementazione aggiuntivi seguenti:

  • Il manifesto dell'applicazione XBAP deve essere configurato appositamente per scaricare la pipeline (cartelle e assembly) e l'assembly del componente aggiuntivo nella cache dell'applicazione ClickOnce nel computer client, nella stessa cartella di XBAP.

  • Il codice XBAP per individuare e caricare i componenti aggiuntivi deve usare la cache dell'applicazione ClickOnce per XBAP come pipeline e percorso del componente aggiuntivo.

  • XBAP deve caricare il componente aggiuntivo in un contesto di sicurezza speciale se il componente aggiuntivo fa riferimento a file separati che si trovano nel sito di origine; se ospitato da XBAP, i componenti aggiuntivi possono fare riferimento solo a file separati che si trovano nel sito di origine dell'applicazione host.

Queste attività sono descritte in dettaglio nelle sottosezioni seguenti.

Configurazione della pipeline e del componente aggiuntivo per la distribuzione ClickOnce

I file XBAP vengono scaricati ed eseguiti da una cartella sicura nella cache di distribuzione ClickOnce. Affinché un XBAP ospiti un componente aggiuntivo, è necessario scaricare anche la pipeline e l'assembly del componente aggiuntivo nella cartella sicura. A tale scopo, è necessario configurare il manifesto dell'applicazione per includere l'assembly della pipeline e del componente aggiuntivo per il download. Questa operazione viene eseguita più facilmente in Visual Studio, anche se la pipeline e l'assembly del componente aggiuntivo devono trovarsi nella cartella radice del progetto XBAP host per consentire a Visual Studio di rilevare gli assembly della pipeline.

Di conseguenza, il primo passaggio consiste nel compilare la pipeline e l'assembly del componente aggiuntivo nella radice del progetto XBAP impostando l'output di compilazione di ogni assembly della pipeline e progetti di assembly del componente aggiuntivo. La tabella seguente illustra i percorsi di output della compilazione per i progetti di assembly della pipeline e il progetto di assembly del componente aggiuntivo che si trovano nella stessa soluzione e cartella radice del progetto XBAP host.

Tabella 1: Percorsi dell'output di compilazione per gli assembly della pipeline ospitati da un'applicazione XBAP

Progetto di assembly della pipeline Percorso dell'output di compilazione
Contratto ..\HostXBAP\Contracts\
Vista del componente aggiuntivo ..\HostXBAP\AddInViews\
Adattatore sul lato del componente aggiuntivo ..\HostXBAP\AddInSideAdapters\
Adattatore sul lato host ..\HostXBAP\HostSideAdapters\
Componente aggiuntivo ..\HostXBAP\AddIns\WPFAddIn1

Il passaggio successivo consiste nel specificare gli assembly della pipeline e l'assembly del componente aggiuntivo come file di contenuto XBAP in Visual Studio eseguendo le operazioni seguenti:

  1. Includere l'assembly della pipeline e del componente aggiuntivo nel progetto facendo clic con il pulsante destro del mouse su ogni cartella della pipeline in Esplora soluzioni e scegliendo Includi nel progetto.

  2. Impostare il valore per Azione di compilazione di ogni assembly della pipeline e del componente aggiuntivo su Contenuto nella finestra Proprietà.

Il passaggio finale consiste nel configurare il manifesto dell'applicazione per includere i file di assembly della pipeline e il file di assembly del componente aggiuntivo per il download. I file devono trovarsi in cartelle nella radice della cartella nella cache ClickOnce occupata dall'applicazione XBAP. La configurazione può essere ottenuta in Visual Studio eseguendo le operazioni seguenti:

  1. Fare clic con il pulsante destro del mouse sul progetto XBAP, scegliere Proprietà, pubblica e quindi fare clic sul pulsante File applicazione.

  2. Nella finestra di dialogo File applicazione impostare il valore di Stato pubblicazione di ogni DLL della pipeline e del componente aggiuntivo su Includi (Auto) e impostare il valore di Gruppo di download per ogni DLL della pipeline e del componente aggiuntivo su (Obbligatorio).

Uso della pipeline e del componente aggiuntivo dalla base dell'applicazione

Quando la pipeline e il componente aggiuntivo sono configurati per la distribuzione ClickOnce, vengono scaricati nella stessa cartella della cache ClickOnce di XBAP. Per usare la pipeline e il componente aggiuntivo da XBAP, il codice XBAP deve recuperarli dalla base dell'applicazione. I vari tipi e membri del modello di componente aggiuntivo .NET Framework per l'uso di pipeline e componenti aggiuntivi offrono un supporto speciale per questo scenario. In primo luogo, il percorso viene identificato dal valore di ApplicationBase enumerazione . Questo valore viene usato con gli overload dei membri pertinenti del componente aggiuntivo per l'uso delle pipeline, che includono quanto segue:

Accesso al sito di origine dell'host

Per assicurare che un componente aggiuntivo possa fare riferimento ai file del sito di origine, tale componente deve essere caricato con lo stesso isolamento di sicurezza dell'applicazione host. Questo livello di sicurezza viene identificato dal valore di AddInSecurityLevel.Host enumerazione e passato al Activate metodo quando viene attivato un componente aggiuntivo.

Architettura dei componenti aggiuntivi WPF

Al livello più alto, come si è visto, WPF consente ai componenti aggiuntivi .NET Framework di implementare interfacce utente (che derivano direttamente o indirettamente da FrameworkElement) usando INativeHandleContracte ViewToContractAdapterContractToViewAdapter. Il risultato è che l'applicazione host viene restituita un oggetto FrameworkElement visualizzato dall'interfaccia utente nell'applicazione host.

Per semplici scenari di componenti aggiuntivi dell'interfaccia utente, questo è il più dettagliato necessario per gli sviluppatori. Per scenari più complessi, in particolare quelli che tentano di usare servizi WPF aggiuntivi, ad esempio layout, risorse e data binding, è necessaria una conoscenza più dettagliata del modo in cui WPF estende il modello di componente aggiuntivo .NET Framework con il supporto dell'interfaccia utente per comprendere i vantaggi e le limitazioni.

Fondamentalmente, WPF non passa un'interfaccia utente da un componente aggiuntivo a un'applicazione host; WPF passa invece l'handle della finestra Win32 per l'interfaccia utente usando l'interoperabilità WPF. Di conseguenza, quando un'interfaccia utente da un componente aggiuntivo viene passata a un'applicazione host, si verifica quanto segue:

  • Sul lato componente aggiuntivo, WPF acquisisce un handle di finestra per l'interfaccia utente che verrà visualizzata dall'applicazione host. L'handle di finestra viene incapsulato da una classe WPF interna che deriva da HwndSource e implementa INativeHandleContract. Un'istanza di questa classe viene restituita da ViewToContractAdapter e viene eseguito il marshalling dal dominio dell'applicazione del componente aggiuntivo al dominio applicazione dell'applicazione host.

  • Sul lato applicazione host WPF ripaccolta come HwndSource classe WPF interna che deriva da HwndHost e utilizza INativeHandleContract. Un'istanza di questa classe viene restituita dall'applicazione ContractToViewAdapter host.

HwndHost esiste per visualizzare le interfacce utente, identificate dagli handle di finestra, dalle interfacce utente WPF. Per altre informazioni, vedere Interoperatività di WPF e Win32.

In sintesi, INativeHandleContract, ViewToContractAdaptere ContractToViewAdapter esistono per consentire il passaggio dell'handle di finestra per un'interfaccia utente WPF da un componente aggiuntivo a un'applicazione host, in cui è incapsulato da un HwndHost oggetto e visualizzato l'interfaccia utente dell'applicazione host.

Nota

Poiché l'applicazione host ottiene un HwndHostoggetto , l'applicazione host non può convertire l'oggetto restituito da ContractToViewAdapter nel tipo implementato come dal componente aggiuntivo , ad esempio .UserControl

Per natura, HwndHost presenta alcune limitazioni che influiscono sul modo in cui le applicazioni host possono usarle. Tuttavia, WPF si estende HwndHost con diverse funzionalità per gli scenari di componenti aggiuntivi. Di seguito sono illustrati i vantaggi e le limitazioni.

Vantaggi dei componenti aggiuntivi WPF

Poiché le interfacce utente dei componenti aggiuntivi WPF vengono visualizzate dalle applicazioni host usando una classe interna che deriva da HwndHost, tali interfacce utente sono vincolate dalle funzionalità di HwndHost rispetto ai servizi dell'interfaccia utente WPF, ad esempio layout, rendering, data binding, stili, modelli e risorse. Wpf, tuttavia, aumenta la sottoclasse interna HwndHost con funzionalità aggiuntive che includono quanto segue:

  • Tabulazione tra l'interfaccia utente di un'applicazione host e l'interfaccia utente di un componente aggiuntivo. Si noti che il modello di programmazione "componente aggiuntivo è un'interfaccia utente" richiede l'override dell'adattatore lato componente aggiuntivo per abilitare la tabulazione, indipendentemente dal fatto che il componente aggiuntivo sia completamente attendibile o parzialmente attendibile QueryContract .

  • Rispettare i requisiti di accessibilità per le interfacce utente del componente aggiuntivo visualizzate dalle interfacce utente dell'applicazione host.

  • Abilitazione dell'esecuzione sicura delle applicazioni WPF in più scenari di dominio applicazione.

  • Impedire l'accesso non valido agli handle della finestra dell'interfaccia utente del componente aggiuntivo quando i componenti aggiuntivi vengono eseguiti con isolamento della sicurezza, ovvero una sandbox di sicurezza parzialmente attendibile. La chiamata ViewToContractAdapter garantisce questa sicurezza:

    • Per il modello di programmazione "add-in restituisce un'interfaccia utente", l'unico modo per passare l'handle della finestra per un'interfaccia utente del componente aggiuntivo attraverso il limite di isolamento consiste nel chiamare ViewToContractAdapter.

    • Per il modello di programmazione "componente aggiuntivo è un'interfaccia utente", è necessario eseguire l'override QueryContract dell'adattatore sul lato componente aggiuntivo e chiamare ViewToContractAdapter (come illustrato negli esempi precedenti), così come chiama l'implementazione dell'adattatore QueryContract sul lato host dall'adattatore sul lato host.

  • Protezione dell'esecuzione per più domini dell'applicazione. A causa delle limitazioni relative ai domini dell'applicazione, le eccezioni non gestite generate nei domini dell'applicazione del componente aggiuntivo provocano un arresto anomalo dell'intera applicazione, anche in presenza di un limite di isolamento. Tuttavia, WPF e il modello di componente aggiuntivo .NET Framework offrono un modo semplice per risolvere questo problema e migliorare la stabilità dell'applicazione. Un componente aggiuntivo WPF che visualizza un'interfaccia utente crea un Dispatcher oggetto per il thread in cui viene eseguito il dominio applicazione, se l'applicazione host è un'applicazione WPF. È possibile rilevare tutte le eccezioni non gestite che si verificano nel dominio dell'applicazione gestendo l'evento UnhandledException del Dispatchercomponente aggiuntivo WPF . È possibile ottenere dalla DispatcherCurrentDispatcher proprietà .

Limitazioni dei componenti aggiuntivi WPF

Oltre ai vantaggi che WPF aggiunge ai comportamenti predefiniti forniti dagli HwndSourcehandle di finestra , HwndHoste , esistono anche limitazioni per le interfacce utente del componente aggiuntivo visualizzate dalle applicazioni host:

  • Le interfacce utente del componente aggiuntivo visualizzate da un'applicazione host non rispettano il comportamento di ritaglio dell'applicazione host.

  • Il concetto di spazio aereo negli scenari di interoperabilità si applica anche ai componenti aggiuntivi (vedere Cenni preliminari sulle aree di tecnologia).

  • I servizi dell'interfaccia utente di un'applicazione host, ad esempio l'ereditarietà delle risorse, il data binding e il comando, non sono automaticamente disponibili per le interfacce utente dei componenti aggiuntivi. Per fornire questi servizi al componente aggiuntivo è necessario aggiornare la pipeline.

  • Un'interfaccia utente del componente aggiuntivo non può essere ruotata, ridimensionata, asimmetrica o interessata da una trasformazione (vedere Cenni preliminari sulle trasformazioni).

  • Il contenuto all'interno delle interfacce utente del componente aggiuntivo di cui viene eseguito il rendering tramite operazioni di disegno dallo System.Drawing spazio dei nomi può includere la fusione alfa. Tuttavia, sia un'interfaccia utente del componente aggiuntivo che l'interfaccia utente dell'applicazione host che lo contiene devono essere opache al 100%. in altre parole, la Opacity proprietà su entrambi deve essere impostata su 1.

  • Se la AllowsTransparency proprietà di una finestra nell'applicazione host che contiene un'interfaccia utente del componente aggiuntivo è impostata su true, il componente aggiuntivo è invisibile. Questo vale anche se l'interfaccia utente del componente aggiuntivo è 100% opaca , ovvero la Opacity proprietà ha un valore 1.

  • Un'interfaccia utente del componente aggiuntivo deve essere visualizzata sopra altri elementi WPF nella stessa finestra di primo livello.

  • Non è possibile eseguire il rendering di alcuna parte dell'interfaccia utente di un componente aggiuntivo usando un oggetto VisualBrush. Al contrario, il componente aggiuntivo può creare uno snapshot dell'interfaccia utente generata per creare una bitmap che può essere passata all'applicazione host usando metodi definiti dal contratto.

  • I file multimediali non possono essere riprodotti da un MediaElement oggetto in un'interfaccia utente del componente aggiuntivo.

  • Gli eventi del mouse generati per l'interfaccia utente del componente aggiuntivo non vengono ricevuti né generati dall'applicazione host e la proprietà per l'interfaccia IsMouseOver utente dell'applicazione host ha il valore false.

  • Quando lo stato attivo si sposta tra i controlli in un'interfaccia utente del componente aggiuntivo, gli GotFocus eventi e LostFocus non vengono ricevuti né generati dall'applicazione host.

  • La parte di un'applicazione host che contiene un'interfaccia utente del componente aggiuntivo viene visualizzata in bianco quando viene stampato.

  • Tutti i dispatcher (vedere Dispatcher) creati dall'interfaccia utente del componente aggiuntivo devono essere arrestati manualmente prima che il componente aggiuntivo proprietario venga scaricato se l'applicazione host continua l'esecuzione. Il contratto può implementare metodi che consentono all'applicazione host di segnalare il componente aggiuntivo prima che il componente aggiuntivo venga scaricato, consentendo così all'interfaccia utente del componente aggiuntivo di arrestare i dispatcher.

  • Se un'interfaccia utente del componente aggiuntivo è o contiene , InkCanvasInkCanvasnon è possibile scaricare il componente aggiuntivo.

Ottimizzazione delle prestazioni

Per impostazione predefinita, quando vengono usati più domini applicazione, i vari assembly .NET Framework richiesti da ogni applicazione vengono tutti caricati nel dominio dell'applicazione. Di conseguenza, il tempo necessario per creare nuovi domini dell'applicazione e avviare le applicazioni al loro interno potrebbe influire sulle prestazioni. Tuttavia, .NET Framework consente di ridurre i tempi di avvio indicando alle applicazioni di condividere assembly tra domini applicazione se sono già caricati. A tale scopo, usare l'attributo LoaderOptimizationAttribute , che deve essere applicato al metodo del punto di ingresso (Main). In questo caso, è necessario usare soltanto il codice per implementare la definizione dell'applicazione (vedere Cenni preliminari sulla gestione di applicazioni).

Vedi anche