Génération d'une application WPF (WPF)Building a WPF Application (WPF)

Applications Windows Presentation Foundation (WPF) peuvent être construites comme .NET Framework.NET Framework exécutables (.exe), des bibliothèques (.dll), ou une combinaison des deux types d’assemblys.Windows Presentation Foundation (WPF) applications can be built as .NET Framework.NET Framework executables (.exe), libraries (.dll), or a combination of both types of assemblies. Cette rubrique présente comment générer des applications WPFWPF et décrit les principales étapes du processus de génération.This topic introduces how to build WPFWPF applications and describes the key steps in the build process.

Génération d'une application WPFBuilding a WPF Application

Une application WPF peut être compilée des façons suivantes :A WPF application can be compiled in the following ways:

Pipeline de génération WPFWPF Build Pipeline

Quand un projet WPFWPF est généré, la combinaison de cibles spécifiques au langage et spécifiques à WPFWPF est appelée.When a WPFWPF project is built, the combination of language-specific and WPFWPF-specific targets are invoked. Le processus d’exécution de ces cibles est appelé le pipeline de génération, et les principales étapes sont illustrées par la figure suivante.The process of executing these targets is called the build pipeline, and the key steps are illustrated by the following figure.

Processus de génération WPFWPF build process

Initialisations avant générationPre-Build Initializations

Avant la génération, MSBuildMSBuild détermine l’emplacement des bibliothèques et des outils importants, dont les éléments suivants :Before building, MSBuildMSBuild determines the location of important tools and libraries, including the following:

  • Le .NET Framework.The .NET Framework.

  • Répertoires SDK WindowsWindows SDK.The SDK WindowsWindows SDK directories.

  • Emplacement des assemblys de référence WPFWPF.The location of WPFWPF reference assemblies.

  • Propriété pour les chemins de recherche des assemblys.The property for the assembly search paths.

Le premier emplacement où MSBuildMSBuild recherche les assemblys est le répertoire de l’assembly de référence (%ProgramFiles%\Reference Assemblies\Microsoft\Framework\v3.0\).The first location where MSBuildMSBuild searches for assemblies is the reference assembly directory (%ProgramFiles%\Reference Assemblies\Microsoft\Framework\v3.0\). Pendant cette étape, le processus de génération initialise également les diverses propriétés et groupes d’éléments, et exécute tout travail de nettoyage nécessaire.During this step, the build process also initializes the various properties and item groups and performs any required cleanup work.

Résolution des référencesResolving References

Le processus de génération localise et lie les assemblys requis pour générer le projet d’application.The build process locates and binds the assemblies required to build the application project. Cette logique est contenue dans la tâche ResolveAssemblyReference.This logic is contained in the ResolveAssemblyReference task. Tous les assemblys déclarés comme Reference dans le fichier projet sont fournis à la tâche, ainsi que des informations sur les chemins de recherche et les métadonnées sur les assemblys déjà installés sur le système.All assemblies declared as Reference in the project file are provided to the task along with information on the search paths and metadata on assemblies already installed on the system. La tâche examine les assemblys et utilise les métadonnées de l’assembly installé pour éliminer par filtrage les principaux assemblys WPFWPF qui ne doivent pas apparaître dans les manifestes de sortie.The task looks up assemblies and uses the installed assembly's metadata to filter out those core WPFWPF assemblies that need not show up in the output manifests. Cela vise à éviter des informations redondantes dans les manifestes ClickOnce.This is done to avoid redundant information in the ClickOnce manifests. Par exemple, comme PresentationFramework.dll peut être considéré comme représentatif d’une application générée sur et pour le WPFWPF et en outre, comme tous les WPFWPF assemblys existent au même emplacement sur chaque ordinateur où le .NET Framework installé, il est inutile d’inclure toutes les informations sur tous les assemblys de référence .NET Framework dans les manifestes.For example, since PresentationFramework.dll can be considered representative of an application built on and for the WPFWPF and moreover since all WPFWPF assemblies exist at the same location on every machine that has the .NET Framework installed, there is no need to include all information on all .NET Framework reference assemblies in the manifests.

Compilation du balisage — Étape 1Markup Compilation—Pass 1

Dans cette étape, les fichiers XAMLXAML sont analysés et compilés afin que le runtime ne perde pas de temps à analyser XMLXML et à valider des valeurs de propriété.In this step, XAMLXAML files are parsed and compiled so that the runtime does not spend time parsing XMLXML and validating property values. Le fichier XAMLXAML compilé est tokenisé au préalable de sorte que, lors de l’exécution, son chargement doit être beaucoup plus rapide que le chargement d’un fichier XAMLXAML.The compiled XAMLXAML file is pre-tokenized so that, at run time, loading it should be much faster than loading a XAMLXAML file.

Pendant cette étape, les activités suivantes ont lieu pour chaque fichier XAMLXAML qui est un élément de génération Page :During this step, the following activities take place for every XAMLXAML file that is a Page build item:

  1. Le fichier XAMLXAML est analysé par le compilateur de balisage.The XAMLXAML file is parsed by the markup compiler.

  2. Une représentation compilée est créée pour ce fichier XAMLXAML et copiée dans le dossier obj\Release.A compiled representation is created for that XAMLXAML and copied to the obj\Release folder.

  3. Une représentation CodeDOM d’une nouvelle classe partielle est créée et copiée dans le dossier obj\Release.A CodeDOM representation of a new partial class is created and copied to the obj\Release folder.

En outre, un fichier de code spécifique au langage est généré pour chaque fichier XAMLXAML.In addition, a language-specific code file is generated for every XAMLXAML file. Par exemple, pour une page Page1.xaml dans un projet Visual Basic, un fichier Page1.g.vb est généré ; pour une page Page1.xaml dans un projet c#, un fichier Page1.g.cs est généré.For example, for a Page1.xaml page in a Visual Basic project, a Page1.g.vb is generated; for a Page1.xaml page in a C# project, a Page1.g.cs is generated. Le « .g » dans le nom de fichier indique que le fichier est du code généré qui a une déclaration de classe partielle pour l’élément de niveau supérieur du fichier de balisage (tel que Page ou Window).The ".g" in the file name indicates the file is generated code that has a partial class declaration for the top-level element of the markup file (such as Page or Window). La classe est déclarée avec le partial modificateur en c# (Extends en Visual Basic) pour indiquer qu’une autre déclaration pour la classe ailleurs, généralement dans le code-behind Page1.xaml.cs de fichiers.The class is declared with the partial modifier in C# (Extends in Visual Basic) to indicate there is another declaration for the class elsewhere, usually in the code-behind file Page1.xaml.cs.

La classe partielle s’étend de la classe de base appropriée (tel que Page pour une page) et implémente la System.Windows.Markup.IComponentConnector interface.The partial class extends from the appropriate base class (such as Page for a page) and implements the System.Windows.Markup.IComponentConnector interface. Le IComponentConnector interface possède des méthodes pour initialiser un composant et connecter des noms et des événements sur les éléments dans son contenu.The IComponentConnector interface has methods to initialize a component and connect names and events on elements in its content. Par conséquent, le fichier de code généré a une implémentation de méthode similaire à la suivante :Consequently, the generated code file has a method implementation like the following:

public void InitializeComponent() {  
    if (_contentLoaded) {  
        return;  
    }  
    _contentLoaded = true;  
    System.Uri resourceLocater =   
        new System.Uri(  
            "window1.xaml",   
            System.UriKind.RelativeOrAbsolute);  
    System.Windows.Application.LoadComponent(this, resourceLocater);  
}  
Public Sub InitializeComponent() _  

    If _contentLoaded Then  
        Return  
    End If  

    _contentLoaded = True  
    Dim resourceLocater As System.Uri = _  
        New System.Uri("mainwindow.xaml", System.UriKind.Relative)  

    System.Windows.Application.LoadComponent(Me, resourceLocater)  

End Sub  

Par défaut, la compilation de balisage s’exécute dans le même AppDomain comme le MSBuildMSBuild moteur.By default, markup compilation runs in the same AppDomain as the MSBuildMSBuild engine. Cela assure des gains de performances significatifs.This provides significant performance gains. Ce comportement peut être basculé avec la propriété AlwaysCompileMarkupFilesInSeparateDomain.This behavior can be toggled with the AlwaysCompileMarkupFilesInSeparateDomain property. Cela présente l’avantage de décharger tous les assemblys de référence en déchargeant le distinct AppDomain.This has the advantage of unloading all reference assemblies by unloading the separate AppDomain.

Compilation du balisage — Étape 2Markup Compilation—Pass 2

Les pages XAMLXAML ne sont pas toutes compilées pendant la première étape de compilation du balisage.Not all XAMLXAML pages are compiled at during pass 1 of markup compilation. Les fichiers XAMLXAML qui ont des références à des types définis localement (références à des types définis dans le code ailleurs dans le même projet) sont exemptés de compilation pour le moment.XAMLXAML files that have locally defined type references (references to types defined in code elsewhere in the same project) are exempt from compilation at this time. En effet, ces types définis localement existent uniquement dans la source et n’ont pas encore été compilés.This is because those locally defined types exist only in source and have not yet been compiled. Pour déterminer ceci, l’analyseur utilise des heuristiques qui impliquent la recherche d’éléments tels que x:Name dans le fichier de balisage.In order to determine this, the parser uses heuristics that involve looking for items such as x:Name in the markup file. Quand une telle instance est trouvée, la compilation de ce fichier de balisage est remise à plus tard jusqu’à ce que les fichiers de code aient été compilés, après quoi la deuxième étape de la compilation du balisage traite ces fichiers.When such an instance is found, that markup file’s compilation is postponed until the code files have been compiled, after which, the second markup compilation pass processes these files.

Classification des fichiersFile Classification

Le processus de génération organise les fichiers de sortie dans différents groupes de ressources en fonction de l’assembly d’application dans lequel ils seront placés.The build process puts output files into different resource groups based on which application assembly they will be placed in. Dans une application non localisée type, tous les fichiers de données marqués comme Resource sont placés dans l’assembly principal (fichier exécutable ou bibliothèque).In a typical nonlocalized application, all data files marked as Resource are placed in the main assembly (executable or library). Quand UICulture est défini dans le projet, tous les fichiers XAMLXAML compilés et les ressources marquées spécifiquement comme spécifiques au langage sont placés dans l’assembly de ressource satellite.When UICulture is set in the project, all compiled XAMLXAML files and those resources specifically marked as language-specific are placed in the satellite resource assembly. En outre, toutes les ressources indépendantes du langage sont placées dans l’assembly principal.Furthermore, all language-neutral resources are placed in the main assembly. Cette détermination est faite lors de cette étape du processus de génération.In this step of the build process, that determination is made.

Les actions de build ApplicationDefinition, Page et Resource dans le fichier projet peuvent être augmentées avec les métadonnées Localizable (les valeurs acceptables sont true et false), qui déterminent si le fichier est spécifique au langage ou indépendant de celui-ci.The ApplicationDefinition, Page, and Resource build actions in the project file can be augmented with the Localizable metadata (acceptable values are true and false), which dictates whether the file is language-specific or language-neutral.

Compilation principaleCore Compilation

L’étape de compilation principale implique la compilation des fichiers de code.The core compile step involves compilation of code files. Cela répond à une logique dans les fichiers cibles Microsoft.CSharp.targets et Microsoft.VisualBasic.targets spécifiques au langage.This is orchestrated by logic in the language-specific targets files Microsoft.CSharp.targets and Microsoft.VisualBasic.targets. Si les heuristiques ont déterminé qu’un seul passage du compilateur de balisage est suffisant, l’assembly principal est alors généré.If heuristics have determined that a single pass of the markup compiler is sufficient, then the main assembly is generated. Toutefois, si un ou plusieurs fichiers XAMLXAML du projet ont des références à des types définis localement, un fichier .dll temporaire est généré afin que les derniers assemblys d’application puissent être créés après la deuxième étape de compilation du balisage.However, if one or more XAMLXAML files in the project have references to locally defined types, then a temporary .dll file is generated so the final application assemblies may be created after the second pass of markup compilation is complete.

Génération de manifesteManifest Generation

À la fin du processus de génération, après que tous les assemblys d’application et les fichiers de contenu sont prêts, les manifestes ClickOnceClickOnce pour l’application sont générés.At the end of the build process, after all the application assemblies and content files are ready, the ClickOnceClickOnce manifests for the application are generated.

Le fichier manifeste de déploiement décrit le modèle de déploiement : la version actuelle, le comportement de mise à jour et l’identité d’éditeur avec la signature numérique.The deployment manifest file describes the deployment model: the current version, update behavior, and publisher identity along with digital signature. Ce manifeste est prévu pour être créé par les administrateurs qui gèrent le déploiement.This manifest is intended to be authored by administrators who handle deployment. L’extension de fichier est .xbap (pour les applications du navigateur XAML (XBAP)XAML browser applications (XBAPs)) et .application pour les applications installées.The file extension is .xbap (for applications du navigateur XAML (XBAP)XAML browser applications (XBAPs)) and .application for installed applications. La première extension est déterminée par la propriété du projet HostInBrowser et, en conséquence, le manifeste identifie l’application comme étant hébergée par le navigateur.The former is dictated by the HostInBrowser project property and as a result the manifest identifies the application as browser-hosted.

Le manifeste de l’application (un fichier .exe.manifest) décrit les assemblys d’application et les bibliothèques dépendantes, et répertorie les autorisations requises par l’application.The application manifest (an .exe.manifest file) describes the application assemblies and dependent libraries and lists permissions required by the application. Ce fichier est prévu pour être créé par le développeur d’applications.This file is intended to be authored by the application developer. Pour lancer une application ClickOnceClickOnce, un utilisateur ouvre le fichier manifeste de déploiement de l’application.In order to launch a ClickOnceClickOnce application, a user opens the application's deployment manifest file.

Ces fichiers manifeste sont toujours créés pour les XBAPXBAPs.These manifest files are always created for XBAPXBAPs. Pour les applications installées, ils ne sont pas créés à moins que la propriété GenerateManifests ne soit spécifiée dans le fichier projet avec la valeur true.For installed applications, they are not created unless the GenerateManifests property is specified in the project file with value true.

XBAPXBAPs obtiennent deux autorisations supplémentaires en plus de celles assignées aux applications de zone Internet typiques : WebBrowserPermission et MediaPermission. get two additional permissions over and above those permissions assigned to typical Internet zone applications: WebBrowserPermission and MediaPermission. Le système de génération WPFWPF déclare ces autorisations dans le manifeste de l’application.The WPFWPF build system declares those permissions in the application manifest.

Prise en charge de la build incrémentielleIncremental Build Support

Le système de génération WPFWPF assure la prise en charge des builds incrémentielles.The WPFWPF build system provides support for incremental builds. Il est assez intelligent pour détecter les modifications apportées au balisage ou au code, et il compile uniquement les artefacts affectés par la modification.It is fairly intelligent about detecting changes made to markup or code, and it compiles only those artifacts affected by the change. Le mécanisme de build incrémentielle utilise les fichiers suivants :The incremental build mechanism uses the following files:

  • Un fichier $(AssemblyName)_MarkupCompiler.Cache pour gérer l’état du compilateur actuel.An $(AssemblyName)_MarkupCompiler.Cache file to maintain current compiler state.

  • Un fichier $(AssemblyName)_MarkupCompiler.lref pour mettre en cache les fichiers XAMLXAML avec les références aux types définis localement.An $(AssemblyName)_MarkupCompiler.lref file to cache the XAMLXAML files with references to locally defined types.

Voici un ensemble de règles qui régissent la build incrémentielle :The following is a set of rules governing incremental build:

  • Le fichier est la plus petite unité au niveau de laquelle le système de génération détecte une modification.The file is the smallest unit at which the build system detects change. Par conséquent, pour un fichier de code, le système de génération ne peut pas déterminer si un type a été modifié ou si du code a été ajouté.So, for a code file, the build system cannot tell if a type was changed or if code was added. Il en va de même pour les fichiers projet.The same holds for project files.

  • Le mécanisme de build incrémentielle doit être informé qu’une page XAMLXAML définit une classe ou utilise d’autres classes.The incremental build mechanism must be cognizant that a XAMLXAML page either defines a class or uses other classes.

  • Si des entrées Reference sont modifiées, vous devez recompiler toutes les pages.If Reference entries change, then recompile all pages.

  • Si un fichier de code est modifié, recompilez toutes les pages avec des références à des types définis localement.If a code file changes, recompile all pages with locally defined type references.

  • Si un fichier XAMLXAML est modifié :If a XAMLXAML file changes:

    • Si XAMLXAML est déclaré comme Page dans le projet : si le fichier XAMLXAML ne contient pas de références à des types définis localement, recompilez ce fichier XAMLXAML plus toutes les pages XAMLXAML avec des références locales ; si le fichier XAMLXAML contient des références locales, recompilez toutes les pages XAMLXAML avec les références locales.If XAMLXAML is declared as Page in the project: if the XAMLXAML does not have locally defined type references, recompile that XAMLXAML plus all XAMLXAML pages with local references; if the XAMLXAML has local references, recompile all XAMLXAML pages with local references.

    • Si XAMLXAML est déclaré comme ApplicationDefinition dans le projet : recompilez toutes les XAMLXAML pages (raison : chaque XAMLXAML fait référence à un Application type peut avoir été modifiée).If XAMLXAML is declared as ApplicationDefinition in the project: recompile all XAMLXAML pages (reason: each XAMLXAML has reference to an Application type that may have changed).

  • Si le fichier projet déclare un fichier de code en tant que définition d’application au lieu d’un fichier XAMLXAML :If the project file declares a code file as application definition instead of a XAMLXAML file:

    • Vérifiez si la valeur ApplicationClassName dans le fichier projet a changé (existe-t-il un nouveau type d’application ?).Check if the ApplicationClassName value in the project file has changed (is there a new application type?). Dans ce cas, recompilez toute l’application.If so, recompile the entire application.

    • Sinon, recompilez toutes les pages XAMLXAML avec des références locales.Otherwise, recompile all XAMLXAML pages with local references.

  • Si un fichier projet change : appliquez toutes les règles précédentes et déterminez ce qui doit être recompilé.If a project file changes: apply all preceding rules and see what needs to be recompiled. Les modifications apportées aux propriétés suivantes entraînent une recompilation complète : AssemblyName, IntermediateOutputPath, RootNamespace et HostInBrowser.Changes to the following properties trigger a complete recompile: AssemblyName, IntermediateOutputPath, RootNamespace, and HostInBrowser.

Les scénarios de recompilation suivants sont possibles :The following recompile scenarios are possible:

  • Toute l’application est recompilée.The entire application is recompiled.

  • Seuls les fichiers XAMLXAML qui contiennent des références à des types définis localement sont recompilés.Only those XAMLXAML files that have locally defined type references are recompiled.

  • Rien n’est recompilé (si rien dans le projet n’a changé).Nothing is recompiled (if nothing in the project has changed).

Voir aussiSee Also

Déploiement d’une application WPFDeploying a WPF Application
Informations de référence sur MSBuild WPFWPF MSBuild Reference
URI à en-tête pack dans WPFPack URIs in WPF
Fichiers de ressources, de contenu et de données d’une application WPFWPF Application Resource, Content, and Data Files