ImportAttribute Classe

Définition

Espace de noms:

System.ComponentModel.Composition

Assembly:

System.ComponentModel.Composition.dll

Paquet:

System.ComponentModel.Composition v8.0.0

Source:

ImportAttribute.cs

Spécifie que la valeur d’une propriété, d’un champ ou d’un paramètre doit être fournie par l’objet CompositionContainer.

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 ImportAttributeet 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 à attributs, le 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’un composant sont remplies par l’objet CompositionContainer auquel appartient cette partie, à l’aide des exportations fournies à cet CompositionContainer objet.

Si une importation correspond à une exportation donnée, il est principalement déterminé 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 ou l’autre de ces éléments lors de l’utilisation de l’attribut import dans le code, et ils sont automatiquement déduits du type du membre décoré. Si l’importation doit correspondre à une exportation d’un autre type (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 distinguer plusieurs contrats du même type, mais il est généralement préférable de le faire par le biais de métadonnées. Pour plus d’informations sur les métadonnées, consultez PartMetadataAttribute.

Constructeurs

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

Propriétés

AllowDefault	Obtient ou définit une valeur qui indique si la propriété, le champ ou le paramètre a pour valeur la valeur par défaut de son type lorsqu'une exportation avec le nom de 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 est recomposé lorsque des exportations avec un contrat correspondant ont changé dans le conteneur.
ContractName	Obtient le nom de 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 requiert un CreationPolicy spécifique pour les exportations utilisées pour satisfaire cette importation.
Source	Obtient ou définit une valeur qui spécifie les portées dont cette importation peut être satisfaite.
TypeId	Lors de l'implémentation dans une classe dérivée, obtient un identificateur unique pour l'objet Attribute. (Hérité de Attribute)

Méthodes

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 de cette instance. (Hérité de Attribute)
GetType()	Obtient le 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 pour la classe dérivée. (Hérité de Attribute)
Match(Object)	En cas de substitution dans une classe dérivée, retourne une valeur indiquant si cette instance équivaut à un objet spécifié. (Hérité de Attribute)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Voir aussi

• ExportAttribute
• Vue d'ensemble du modèle de programmation par attributs