ImportAttribute Osztály

Definíció

Névtér:

System.ComponentModel.Composition

Szerelvény:

System.ComponentModel.Composition.dll

Csomag:

System.ComponentModel.Composition v11.0.0-preview.4.26230.115

Forrás:

ImportAttribute.cs

Megadja, hogy a .object tulajdonságot, mezőt vagy paraméterértéket CompositionContaineradjon meg.

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

Öröklődés

Object

Attribute

ImportAttribute

Attribútumok

AttributeUsageAttribute

Példák

Az alábbi példa három osztályt mutat be, a tagokat a ImportAttribute, és három exportálást, amelyek megfelelnek nekik.

//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

Megjegyzések

Az attribútumos programozási modellben az ImportAttribute adott rész importálásainak vagy függőségeinek deklarálására szolgál. Egy tulajdonságot, mezőt vagy metódust díszíthet. Az összetétel során a rész importálását az a tárgy tölti ki, amelyhez az CompositionContainer adott rész tartozik, az adott CompositionContainer objektumhoz megadott exportálások használatával.

Azt, hogy egy importálás megfelel-e egy adott exportálásnak, elsősorban a szerződés nevének és a szerződés típusának összehasonlítása határozza meg. Általában ezek egyikét sem kell megadnia az importálási attribútum kódban való használatakor, és ezek automatikusan ki lesznek következtetve a kitüntetett tag típusából. Ha az importálásnak meg kell egyeznie egy másik típusú exportálással (például a kitüntetett tag típusának alosztályával vagy az adott tag által implementált felülettel), akkor explicit módon meg kell adni a szerződés típusát. A szerződés neve explicit módon is megadható, például több azonos típusú szerződés megkülönböztetéséhez, de általában jobb ezt metaadatokon keresztül elvégezni. A metaadatokkal kapcsolatos további információkért lásd: PartMetadataAttribute.

Konstruktorok

Name	Description
ImportAttribute()	Inicializálja az ImportAttribute osztály új példányát, és importálja az exportálást az alapértelmezett szerződésnévvel.
ImportAttribute(String, Type)	Inicializálja az ImportAttribute osztály új példányát, és importálja az exportálást a megadott szerződésnévvel és típussal.
ImportAttribute(String)	Inicializálja az ImportAttribute osztály új példányát, és importálja az exportálást a megadott szerződésnévvel.
ImportAttribute(Type)	Inicializálja az ImportAttribute osztály új példányát, és importálja az exportálást a megadott típusból származtatott szerződésnévvel.

Tulajdonságok

Name	Description
AllowDefault	Lekéri vagy beállít egy értéket, amely jelzi, hogy a tulajdonság, mező vagy paraméter a típus alapértelmezett értékére lesz-e állítva, ha a szerződésnévvel rendelkező exportálás nincs jelen a tárolóban.
AllowRecomposition	Lekéri vagy beállít egy értéket, amely jelzi, hogy a tulajdonság vagy mező újra lesz-e komposztolva, ha egyező szerződéssel rendelkező exportálás módosult a tárolóban.
ContractName	Lekéri az importálni kívánt exportálás szerződésnevét.
ContractType	Lekéri az importálni kívánt exportálás típusát.
RequiredCreationPolicy	Olyan értéket kap vagy állít be, amely azt jelzi, hogy az importálónak egy adott CreationPolicy exportra van szüksége az import teljesítéséhez.
Source	Lekéri vagy beállít egy értéket, amely meghatározza azokat a hatóköröket, amelyekből az importálás teljesülhet.

Lásd még

• ExportAttribute
• Attribútumos programozási modell áttekintése