class/System.ComponentModel.Composition/src/ComponentModel/System/ComponentModel/Composition/AttributedModel/AttributedModelDiscovery.cs

   1 // -----------------------------------------------------------------------
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.
   3 // -----------------------------------------------------------------------
   4 using System;
   5 using System.ComponentModel.Composition.Diagnostics;
   6 using System.ComponentModel.Composition.Hosting;
   7 using System.ComponentModel.Composition.Primitives;
   8 using System.ComponentModel.Composition.ReflectionModel;
   9 using System.Reflection;
  10 using Microsoft.Internal;
  11
  12 namespace System.ComponentModel.Composition.AttributedModel
  13 {
  14     internal static class AttributedModelDiscovery
  15     {
  16         public static ComposablePartDefinition CreatePartDefinitionIfDiscoverable(Type type, ICompositionElement origin)
  17         {
  18             AttributedPartCreationInfo creationInfo = new AttributedPartCreationInfo(type, null, false, origin);
  19             if (!creationInfo.IsPartDiscoverable())
  20             {
  21                 return null;
  22             }
  23
  24             return new ReflectionComposablePartDefinition(creationInfo);
  25         }
  26
  27         public static ReflectionComposablePartDefinition CreatePartDefinition(Type type, PartCreationPolicyAttribute partCreationPolicy, bool ignoreConstructorImports, ICompositionElement origin)
  28         {
  29             Assumes.NotNull(type);
  30
  31             AttributedPartCreationInfo creationInfo = new AttributedPartCreationInfo(type, partCreationPolicy, ignoreConstructorImports, origin);
  32
  33             return new ReflectionComposablePartDefinition(creationInfo);
  34         }
  35
  36         public static ReflectionComposablePart CreatePart(object attributedPart)
  37         {
  38             Assumes.NotNull(attributedPart);
  39
  40             // If given an instance then we want to pass the default composition options because we treat it as a shared part
  41             // TODO: ICompositionElement Give this def an origin indicating that it was added directly to the ComposablePartExportProvider.
  42
  43             ReflectionComposablePartDefinition definition = AttributedModelDiscovery.CreatePartDefinition(attributedPart.GetType(), PartCreationPolicyAttribute.Shared, true, (ICompositionElement)null);
  44
  45             return new ReflectionComposablePart(definition, attributedPart);
  46         }
  47
  48         public static ReflectionParameterImportDefinition CreateParameterImportDefinition(ParameterInfo parameter, ICompositionElement origin)
  49         {
  50             Requires.NotNull(parameter, "parameter");
  51
  52             ReflectionParameter reflectionParameter = parameter.ToReflectionParameter();
  53             IAttributedImport attributedImport = AttributedModelDiscovery.GetAttributedImport(reflectionParameter, parameter);
  54             ImportType importType = new ImportType(reflectionParameter.ReturnType, attributedImport.Cardinality);
  55
  56             if (importType.IsPartCreator)
  57             {
  58                 return new PartCreatorParameterImportDefinition(
  59                     new Lazy<ParameterInfo>(() => parameter),
  60                     origin,
  61                     new ContractBasedImportDefinition(
  62                         attributedImport.GetContractNameFromImport(importType),
  63                         attributedImport.GetTypeIdentityFromImport(importType),
  64                         CompositionServices.GetRequiredMetadata(importType.MetadataViewType),
  65                         attributedImport.Cardinality,
  66                         false,
  67                         true,
  68                         CreationPolicy.NonShared));
  69             }
  70             else
  71             {
  72                 return new ReflectionParameterImportDefinition(
  73                     new Lazy<ParameterInfo>(() => parameter),
  74                     attributedImport.GetContractNameFromImport(importType),
  75                     attributedImport.GetTypeIdentityFromImport(importType),
  76                     CompositionServices.GetRequiredMetadata(importType.MetadataViewType),
  77                     attributedImport.Cardinality,
  78                     attributedImport.RequiredCreationPolicy,
  79                     origin);
  80             }
  81         }
  82
  83         public static ReflectionMemberImportDefinition CreateMemberImportDefinition(MemberInfo member, ICompositionElement origin)
  84         {
  85             Requires.NotNull(member, "member");
  86
  87             ReflectionWritableMember reflectionMember = member.ToReflectionWritableMember();
  88             IAttributedImport attributedImport = AttributedModelDiscovery.GetAttributedImport(reflectionMember, member);
  89             ImportType importType = new ImportType(reflectionMember.ReturnType, attributedImport.Cardinality);
  90
  91             if (importType.IsPartCreator)
  92             {
  93                 return new PartCreatorMemberImportDefinition(
  94                     new LazyMemberInfo(member),
  95                     origin,
  96                     new ContractBasedImportDefinition(
  97                         attributedImport.GetContractNameFromImport(importType),
  98                         attributedImport.GetTypeIdentityFromImport(importType),
  99                         CompositionServices.GetRequiredMetadata(importType.MetadataViewType),
 100                         attributedImport.Cardinality,
 101                         attributedImport.AllowRecomposition,
 102                         false,
 103                         CreationPolicy.NonShared));
 104             }
 105             else
 106             {
 107                 return new ReflectionMemberImportDefinition(
 108                     new LazyMemberInfo(member),
 109                     attributedImport.GetContractNameFromImport(importType),
 110                     attributedImport.GetTypeIdentityFromImport(importType),
 111                     CompositionServices.GetRequiredMetadata(importType.MetadataViewType),
 112                     attributedImport.Cardinality,
 113                     attributedImport.AllowRecomposition,
 114                     attributedImport.RequiredCreationPolicy,
 115                     origin);
 116             }
 117         }
 118
 119         private static IAttributedImport GetAttributedImport(ReflectionItem item, ICustomAttributeProvider attributeProvider)
 120         {
 121             IAttributedImport[] imports = attributeProvider.GetAttributes<IAttributedImport>(false);
 122
 123             // For constructor parameters they may not have an ImportAttribute
 124             if (imports.Length == 0)
 125             {
 126                 return new ImportAttribute();
 127             }
 128
 129             if (imports.Length > 1)
 130             {
 131                 CompositionTrace.MemberMarkedWithMultipleImportAndImportMany(item);
 132             }
 133
 134             // Regardless of how many imports, always return the first one
 135             return imports[0];
 136         }
 137     }
 138 }