ImportAttribute Classe

Définition

Espace de noms:: System.ComponentModel.Composition

Assembly:: System.ComponentModel.Composition.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Spécifie qu’une propriété, un champ ou une valeur de paramètre doit être fournie par le CompositionContainer.object.

public ref class ImportAttribute : Attribute

[System.AttributeUsage(System.AttributeTargets.Field | System.AttributeTargets.Parameter | System.AttributeTargets.Property, AllowMultiple=false, Inherited=false)]
public class ImportAttribute : Attribute

[<System.AttributeUsage(System.AttributeTargets.Field | System.AttributeTargets.Parameter | System.AttributeTargets.Property, AllowMultiple=false, Inherited=false)>]
type ImportAttribute = class
    inherit Attribute

Public Class ImportAttribute
Inherits Attribute

Héritage: Object

Attribute
ImportAttribute

Attributs: AttributeUsageAttribute

Exemples

L’exemple suivant montre trois classes avec des membres décorés avec le ImportAttribute, et trois exportations qui les correspondent.

//Default export infers type and contract name from the
//exported type.  This is the preferred method.
[Export]
public class MyExport1
{
    public String data = "Test Data 1.";
}

public class MyImporter1
{
    [Import]
    public MyExport1 importedMember { get; set; }
}

public interface MyInterface
{
}

//Specifying the contract type may be important if
//you want to export a type other then the base type,
//such as an interface.
[Export(typeof(MyInterface))]
public class MyExport2 : MyInterface
{
    public String data = "Test Data 2.";
}

public class MyImporter2
{
    //The import must match the contract type!
    [Import(typeof(MyInterface))]
    public MyExport2 importedMember { get; set; }
}

//Specifying a contract name should only be
//needed in rare caes. Usually, using metadata
//is a better approach.
[Export("MyContractName", typeof(MyInterface))]
public class MyExport3 : MyInterface
{
    public String data = "Test Data 3.";
}

public class MyImporter3
{
    //Both contract name and type must match!
    [Import("MyContractName", typeof(MyInterface))]
    public MyExport3 importedMember { get; set; }
}

class Program
{

    static void Main(string[] args)
    {
        AggregateCatalog catalog = new AggregateCatalog();
        catalog.Catalogs.Add(new AssemblyCatalog(typeof(MyExport1).Assembly));
        CompositionContainer _container = new CompositionContainer(catalog);
        MyImporter1 test1 = new MyImporter1();
        MyImporter2 test2 = new MyImporter2();
        MyImporter3 test3 = new MyImporter3();
        _container.SatisfyImportsOnce(test1);
        _container.SatisfyImportsOnce(test2);
        _container.SatisfyImportsOnce(test3);
        Console.WriteLine(test1.importedMember.data);
        Console.WriteLine(test2.importedMember.data);
        Console.WriteLine(test3.importedMember.data);
        Console.ReadLine();
    }
}

'Default export infers type and contract name from the
'exported type.  This is the preferred method.
<Export()>
Public Class MyExport1
    Public ReadOnly Property data As String
        Get
            Return "Test Data 1."
        End Get
    End Property
End Class

Public Class MyImporter1

    <Import()>
    Public Property ImportedMember As MyExport1

End Class

Public Interface MyInterface

End Interface

'Specifying the contract type may be important if
'you want to export a type other then the base type,
'such as an interface.
<Export(GetType(MyInterface))>
Public Class MyExport2
    Implements MyInterface
    Public ReadOnly Property data As String
        Get
            Return "Test Data 2."
        End Get
    End Property
End Class

Public Class MyImporter2
    'The import must match the contract type!
    <Import(GetType(MyInterface))>
    Public Property ImportedMember As MyExport2
End Class

'Specifying a contract name should only be 
'needed in rare caes. Usually, using metadata
'is a better approach.
<Export("MyContractName", GetType(MyInterface))>
Public Class MyExport3
    Implements MyInterface
    Public ReadOnly Property data As String
        Get
            Return "Test Data 3."
        End Get
    End Property
End Class

Public Class MyImporter3
    'Both contract name and type must match!
    <Import("MyContractName", GetType(MyInterface))>
    Public Property ImportedMember As MyExport3
End Class



Sub Main()
    Dim catalog As AggregateCatalog = New AggregateCatalog()
    catalog.Catalogs.Add(New AssemblyCatalog(GetType(MyExport1).Assembly))
    Dim container As CompositionContainer = New CompositionContainer(catalog)
    Dim test1 As MyImporter1 = New MyImporter1()
    Dim test2 As MyImporter2 = New MyImporter2()
    Dim test3 As MyImporter3 = New MyImporter3()
    container.SatisfyImportsOnce(test1)
    container.SatisfyImportsOnce(test2)
    container.SatisfyImportsOnce(test3)
    Console.WriteLine(test1.ImportedMember.data)
    Console.WriteLine(test2.ImportedMember.data)
    Console.WriteLine(test3.ImportedMember.data)
    Console.ReadLine()
End Sub

Remarques

Dans le modèle de programmation attribué, il ImportAttribute est utilisé pour déclarer les importations, ou dépendances, d’une partie donnée. Il peut décorer une propriété, un champ ou une méthode. Pendant la composition, les importations d’une partie sont remplies par l’objet CompositionContainer auquel appartient cette partie, en utilisant les exportations fournies à cet CompositionContainer objet.

Si une importation correspond à une exportation donnée est déterminée principalement en comparant le nom du contrat et le type de contrat. En règle générale, vous n’avez pas besoin de spécifier l’un de ces éléments lors de l’utilisation de l’attribut d’importation dans le code, et ils seront automatiquement déduits du type du membre décoré. Si l’importation doit correspondre à une exportation d’un type différent (par exemple, une sous-classe du type du membre décoré ou une interface implémentée par ce membre), le type de contrat doit être spécifié explicitement. Le nom du contrat peut également être spécifié explicitement, par exemple pour faire la distinction entre plusieurs contrats avec le même type, mais il est généralement préférable de le faire via des métadonnées. Pour plus d’informations sur les métadonnées, consultez PartMetadataAttribute.

Constructeurs

Nom	Description
ImportAttribute()	Initialise une nouvelle instance de la ImportAttribute classe, en important l’exportation avec le nom de contrat par défaut.
ImportAttribute(String, Type)	Initialise une nouvelle instance de la ImportAttribute classe, en important l’exportation avec le nom et le type de contrat spécifiés.
ImportAttribute(String)	Initialise une nouvelle instance de la ImportAttribute classe, en important l’exportation avec le nom de contrat spécifié.
ImportAttribute(Type)	Initialise une nouvelle instance de la ImportAttribute classe, en important l’exportation avec le nom de contrat dérivé du type spécifié.

Propriétés

Nom	Description
AllowDefault	Obtient ou définit une valeur qui indique si la propriété, le champ ou le paramètre est défini sur la valeur par défaut de son type lorsqu’une exportation avec le nom du contrat n’est pas présente dans le conteneur.
AllowRecomposition	Obtient ou définit une valeur qui indique si la propriété ou le champ sera recomposé lorsque les exportations avec un contrat correspondant ont changé dans le conteneur.
ContractName	Obtient le nom du contrat de l’exportation à importer.
ContractType	Obtient le type de l’exportation à importer.
RequiredCreationPolicy	Obtient ou définit une valeur qui indique que l’importateur a besoin d’une valeur spécifique CreationPolicy pour les exportations utilisées pour satisfaire cette importation.
Source	Obtient ou définit une valeur qui spécifie les étendues à partir desquelles cette importation peut être satisfaite.
TypeId	En cas d’implémentation dans une classe dérivée, obtient un identificateur unique pour cette Attribute. (Hérité de Attribute)

Méthodes

Nom	Description
Equals(Object)	Retourne une valeur qui indique si cette instance est égale à un objet spécifié. (Hérité de Attribute)
GetHashCode()	Retourne le code de hachage pour cette instance. (Hérité de Attribute)
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
IsDefaultAttribute()	En cas de substitution dans une classe dérivée, indique si la valeur de cette instance est la valeur par défaut de la classe dérivée. (Hérité de Attribute)
Match(Object)	En cas de substitution dans une classe dérivée, retourne une valeur qui indique si cette instance est égale à un objet spécifié. (Hérité de Attribute)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)

Implémentations d’interfaces explicites

Nom	Description
_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch. (Hérité de Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)	Récupère les informations de type d’un objet, qui peuvent être utilisées pour obtenir les informations de type d’une interface. (Hérité de Attribute)
_Attribute.GetTypeInfoCount(UInt32)	Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). (Hérité de Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Fournit l’accès aux propriétés et méthodes exposées par un objet. (Hérité de Attribute)

S’applique à

Voir aussi

Commentaires

Cette page a-t-elle été utile ?