Options du compilateur C# qui spécifient des entrées

Les options suivantes contrôlent les entrées du compilateur. La nouvelle syntaxe MSBuild est affichée en gras. La syntaxe csc.exe plus ancienne est indiquée dans code style.

• Références / -reference ou -references: référencer des métadonnées à partir du fichier ou des fichiers d’assembly spécifiés.
• AddModules / -addmodule : Ajouter un module (créé avec target:module cet assembly.)
• EmbedInteropTypes : incorporer des / -linkmétadonnées à partir des fichiers d’assembly d’interopérabilité spécifiés.

références

L’option Références permet au compilateur d’importer des informations de type public dans le fichier spécifié dans le projet actuel, ce qui vous permet de référencer des métadonnées à partir des fichiers d’assembly spécifiés.

<Reference Include="filename" />

filename est le nom d’un fichier qui contient un manifeste d’assembly. Pour importer plusieurs fichiers, incluez un élément Reference distinct pour chaque fichier. Vous pouvez définir un alias en tant qu’élément enfant de l’élément Reference :

<Reference Include="filename.dll">
  <Aliases>LS</Aliases>
</Reference>

Dans l’exemple précédent, LS est l’identificateur C# valide qui représente un espace de noms racine qui contiendra tous les espaces de noms dans l’assembly filename.dll. Les fichiers que vous importez doivent contenir un manifeste. Utilisez AdditionalLibPaths pour spécifier le répertoire dans lequel se trouvent une ou plusieurs de vos références d’assembly. La rubrique AdditionalLibPaths traite également des répertoires dans lesquels le compilateur recherche des assemblys. Pour que le compilateur reconnaisse un type dans un assembly, et non dans un module, il doit être forcé de résoudre le type, que vous pouvez faire en définissant une instance du type. Il existe d’autres façons de résoudre les noms de types dans un assembly pour le compilateur : par exemple, si vous héritez d’un type dans un assembly, le nom du type est alors reconnu par le compilateur. Il est parfois nécessaire de référencer deux versions différentes du même composant à partir d’un assembly. Pour ce faire, utilisez l’élément Aliases de l’élément References pour chaque fichier pour faire la distinction entre les deux fichiers. Cet alias sera utilisé comme qualificateur pour le nom du composant et sera résolu en composant dans l’un des fichiers.

AddModules

Cette option ajoute un module créé avec le <TargetType>module</TargetType> commutateur à la compilation actuelle :

<AddModule Include=file1 />
<AddModule Include=file2 />

Où file, file2 sont des fichiers de sortie qui contiennent des métadonnées. Le fichier ne peut pas contenir de manifeste d’assembly. Pour importer plusieurs fichiers, séparez les noms de fichiers avec une virgule ou un point-virgule. Tous les modules ajoutés avec AddModules doivent se trouver dans le même répertoire que le fichier de sortie au moment de l’exécution. Autrement dit, vous pouvez spécifier un module dans n’importe quel répertoire au moment de la compilation, mais le module doit se trouver dans le répertoire de l’application au moment de l’exécution. Si le module n’est pas dans le répertoire de l’application au moment de l’exécution, vous obtiendrez un TypeLoadException. file ne peut pas contenir d’assembly. Par exemple, si le fichier de sortie a été créé avec l’option TargetType du module, ses métadonnées peuvent être importées avec AddModules.

Si le fichier de sortie a été créé avec une option TargetType autre que le module, ses métadonnées ne peuvent pas être importées avec AddModules , mais peuvent être importées avec l’option Références .

EmbedInteropTypes

Fait en sorte que le compilateur rende les informations de type COM dans les assemblys spécifiés disponibles pour le projet que vous compilez actuellement.

<References>
  <EmbedInteropTypes>file1;file2;file3</EmbedInteropTypes>
</References>

Où file1;file2;file3 est une liste délimitée par des points-virgules de noms de fichiers d’assembly. Si le nom de fichier contient un espace, placez le nom entre guillemets. L’option EmbedInteropTypes vous permet de déployer une application qui contient des informations de type incorporées. L’application peut ensuite utiliser des types dans un assembly runtime qui implémentent les informations de type incorporées sans nécessiter de référence à l’assembly runtime. Si différentes versions de l’assembly runtime sont publiées, l’application qui contient les informations de type incorporées peut fonctionner avec les différentes versions sans avoir à être recompilée. Pour obtenir un exemple, consultez procédure pas à pas : incorporation de types à partir d’assemblys managés.

L’utilisation de l’option EmbedInteropTypes est particulièrement utile lorsque vous travaillez avec l’interopérabilité COM. Vous pouvez incorporer des types COM afin que votre application ne nécessite plus d’assembly PIA (Primary Interop Assembly) sur l’ordinateur cible. L’option EmbedInteropTypes indique au compilateur d’incorporer les informations de type COM de l’assembly d’interopérabilité référencé dans le code compilé résultant. Le type COM est identifié par la valeur CLSID (GUID). Par conséquent, votre application peut s’exécuter sur un ordinateur cible qui a installé les mêmes types COM avec les mêmes valeurs CLSID. Les applications qui automatisent Microsoft Office sont un bon exemple. Étant donné que les applications comme Office conservent généralement la même valeur CLSID entre différentes versions, votre application peut utiliser les types COM référencés tant que .NET Framework 4 ou version ultérieure est installé sur l’ordinateur cible et que votre application utilise des méthodes, des propriétés ou des événements inclus dans les types COM référencés. L’option EmbedInteropTypes incorpore uniquement les interfaces, les structures et les délégués. L’incorporation de classes COM n’est pas prise en charge.

Comme l’option du compilateur Références , l’option du compilateur EmbedInteropTypes utilise le fichier de réponse Csc.rsp, qui fait référence à des assemblys .NET fréquemment utilisés. Utilisez l’option du compilateur NoConfig si vous ne souhaitez pas que le compilateur utilise le fichier Csc.rsp.

// The following code causes an error if ISampleInterface is an embedded interop type.
ISampleInterface<SampleType> sample;

Les types qui ont un paramètre générique dont le type est incorporé à partir d’un assembly d’interopérabilité ne peuvent pas être utilisés si ce type provient d’un assembly externe. Cette restriction ne s’applique pas aux interfaces. Par exemple, considérez l’interface Range définie dans l’assembly Microsoft.Office.Interop.Excel . Si une bibliothèque incorpore des types d’interopérabilité à partir de l’assembly Microsoft.Office.Interop.Excel et expose une méthode qui retourne un type générique qui a un paramètre dont le type est l’interface Range , cette méthode doit retourner une interface générique, comme illustré dans l’exemple de code suivant.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Office.Interop.Excel;

public class Utility
{
    // The following code causes an error when called by a client assembly.
    public List<Range> GetRange1()
    {
        return null;
    }

    // The following code is valid for calls from a client assembly.
    public IList<Range> GetRange2()
    {
        return null;
    }
}

Dans l’exemple suivant, le code client peut appeler la méthode qui retourne l’interface IList générique sans erreur.

public class Client
{
    public void Main()
    {
        Utility util = new Utility();

        // The following code causes an error.
        List<Range> rangeList1 = util.GetRange1();

        // The following code is valid.
        List<Range> rangeList2 = (List<Range>)util.GetRange2();
    }
}