private ImportDefinition CreateWrapped(ContractBasedImportDefinition import, Type type)
{
if (ReflectionModelServices.IsImportingParameter(import))
{
return(ReflectionModelServices.CreateImportDefinition(
this.CreateWrapped(ReflectionModelServices.GetImportingParameter(import), type),
import.ContractName,
import.RequiredTypeIdentity,
import.RequiredMetadata,
import.Cardinality,
import.RequiredCreationPolicy,
null));
}
else
{
return(ReflectionModelServices.CreateImportDefinition(
this.CreateWrapped(ReflectionModelServices.GetImportingMember(import), type),
import.ContractName,
import.RequiredTypeIdentity,
import.RequiredMetadata,
import.Cardinality,
import.IsRecomposable,
import.RequiredCreationPolicy,
null));
}
}
public SerializableImportDefinition(ImportDefinition importDefinition)
{
IsExportFactory = ReflectionModelServices.IsExportFactoryImportDefinition(importDefinition);
if (IsExportFactory)
{
// Handle export factories.
importDefinition = ReflectionModelServices.GetExportFactoryProductImportDefinition(importDefinition);
}
ContractName = importDefinition.ContractName;
Cardinality = importDefinition.Cardinality;
IsRecomposable = importDefinition.IsRecomposable;
IsPrerequisite = importDefinition.IsPrerequisite;
Metadata = new SerializableDictionary <string, object>(importDefinition.Metadata);
ImportingMember = ReflectionModelServices.IsImportingParameter(importDefinition) ?
new SerializableLazyMemberInfo(ReflectionModelServices.GetImportingParameter(importDefinition).Value) :
new SerializableLazyMemberInfo(ReflectionModelServices.GetImportingMember(importDefinition));
var contractBasedImportDefinition = importDefinition as ContractBasedImportDefinition;
if (contractBasedImportDefinition != null)
{
RequiredTypeIdentity = contractBasedImportDefinition.RequiredTypeIdentity;
RequiredCreationPolicy = contractBasedImportDefinition.RequiredCreationPolicy;
RequiredMetadata = new SerializableDictionary <string, string>(contractBasedImportDefinition.RequiredMetadata.Select(kvp => new KeyValuePair <string, string>(kvp.Key, kvp.Value.AssemblyQualifiedName)));
}
}
public static IDictionary <string, object> WriteImportDefinition(ComposablePartDefinition owner, ContractBasedImportDefinition importDefinition)
{
Assumes.NotNull(owner);
Assumes.NotNull(importDefinition);
Lazy <Type> partType = ReflectionModelServices.GetPartType(owner);
IDictionary <string, object> cache = new Dictionary <string, object>();
cache.WriteContractName(importDefinition.ContractName);
cache.WriteValue(AttributedCacheServices.CacheKeys.RequiredTypeIdentity, importDefinition.RequiredTypeIdentity, null);
cache.WriteRequiredMetadata(importDefinition.RequiredMetadata);
cache.WriteValue(AttributedCacheServices.CacheKeys.RequiredCreationPolicy, importDefinition.RequiredCreationPolicy, CreationPolicy.Any);
cache.WriteValue(AttributedCacheServices.CacheKeys.Cardinality, importDefinition.Cardinality, ImportCardinality.ExactlyOne);
if (ReflectionModelServices.IsImportingParameter(importDefinition))
{
cache.WriteValue(AttributedCacheServices.CacheKeys.ImportType, AttributedCacheServices.ImportTypes.Parameter);
cache.WriteLazyParameter(
ReflectionModelServices.GetImportingParameter(importDefinition),
partType);
}
else
{
// don't write anything for import type - member assumed
LazyMemberInfo importingMemberInfo = ReflectionModelServices.GetImportingMember(importDefinition);
cache.WriteValue(AttributedCacheServices.CacheKeys.IsRecomposable, importDefinition.IsRecomposable, false);
cache.WriteValue(AttributedCacheServices.CacheKeys.MemberType, importingMemberInfo.MemberType, MemberTypes.Property);
cache.WriteLazyAccessors(
importingMemberInfo.GetAccessors(),
partType);
}
return(cache);
}
private static Type GetParameterType(ImportDefinition definition)
{
var importingParameter = ReflectionModelServices.GetImportingParameter(definition);
var parameterInfo = importingParameter.Value;
var importDefinitionType = parameterInfo.ParameterType;
return(importDefinitionType);
}
private static SerializableImportDefinition CreateConstructorParameterImport(
ContractBasedImportDefinition import,
Func <Type, TypeIdentity> identityGenerator)
{
var parameterInfo = ReflectionModelServices.GetImportingParameter(import);
var requiredType = ExtractRequiredType(parameterInfo.Value.GetCustomAttributes(), parameterInfo.Value.ParameterType);
if (requiredType == null)
{
return(null);
}
return(ConstructorBasedImportDefinition.CreateDefinition(
import.ContractName,
TypeIdentity.CreateDefinition(requiredType),
import.Cardinality,
import.RequiredCreationPolicy,
parameterInfo.Value,
identityGenerator));
}
private object[] GetArguments(Delegate valueFactory)
{
var arguments = new object[valueFactory.GetMethodInfo().GetParameters().Length];
var ctorImportDefinitions = ImportDefinitions.Where(ReflectionModelServices.IsImportingParameter);
foreach (var ctorImportDefinition in ctorImportDefinitions)
{
var parameterInfo = ReflectionModelServices.GetImportingParameter(ctorImportDefinition).Value;
if (_imports.TryGetValue(ctorImportDefinition, out var value))
{
arguments[parameterInfo.Position] = value.Single().Value;
_imports.Remove(ctorImportDefinition);
}
else
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "There is no export for parameter of type {0}",
parameterInfo.ParameterType));
}
}
return(arguments);
}
private void RewriteContract(Type typeToDecorate, IList <ImportDefinition> importDefs, string newContract)
{
var importToDecorate = importDefs.SingleOrDefault(d => d.ContractName == myContractName);
Contract.Requires(importToDecorate != null, "No import found for contract {0} on type {1}", myContractName, typeToDecorate);
importDefs.Remove(importToDecorate);
Contract.Invariant(importToDecorate.Cardinality == ImportCardinality.ExactlyOne, "Decoration of Cardinality " + importToDecorate.Cardinality + " not supported");
Contract.Invariant(ReflectionModelServices.IsImportingParameter(importToDecorate), "Decoration of property injection not supported");
var param = ReflectionModelServices.GetImportingParameter(importToDecorate);
var importDef = ReflectionModelServices.CreateImportDefinition(
param,
newContract,
AttributedModelServices.GetTypeIdentity(param.Value.ParameterType),
Enumerable.Empty <KeyValuePair <string, Type> >(),
importToDecorate.Cardinality,
CreationPolicy.Any,
null);
importDefs.Add(importDef);
}
public static IEnumerable <Attribute> GetImportDefinitionAttributes(ImportDefinition definition)
{
if (ReflectionModelServices.IsImportingParameter(definition))
{
var parameter = ReflectionModelServices.GetImportingParameter(definition);
foreach (var attribute in Attribute.GetCustomAttributes(parameter.Value, true))
{
yield return(attribute);
}
}
else
{
var member = ReflectionModelServices.GetImportingMember(definition);
MemberInfo attributedMember = null;
switch (member.MemberType)
{
case MemberTypes.Property:
attributedMember = FindProperty(member);
break;
case MemberTypes.Field:
attributedMember = member.GetAccessors()[0];
break;
}
if (attributedMember != null)
{
foreach (var attribute in Attribute.GetCustomAttributes(attributedMember, true))
{
yield return(attribute);
}
}
}
}
static Type GetTargetPartCreatorType(ContractBasedImportDefinition partCreatorImportDefinition)
{
Type importType = null;
var member = ReflectionModelServices.GetImportingMember(partCreatorImportDefinition);
if (member != null)
{
var setMi = member.GetAccessors()
.Where(a => a.Name.StartsWith(PropertySetterPrefix))
.OfType <MethodInfo>()
.SingleOrDefault();
if (setMi != null)
{
importType = setMi.GetParameters()
.First()
.ParameterType;
}
else
{
importType = member.GetAccessors()
.OfType <FieldInfo>()
.Single()
.FieldType;
}
}
else
{
var param = ReflectionModelServices.GetImportingParameter(partCreatorImportDefinition);
if (param != null)
{
importType = param.Value.ParameterType;
}
else
{
throw new NotSupportedException("Import type not supported.");
}
}
if (partCreatorImportDefinition.Cardinality == ImportCardinality.ZeroOrMore)
{
if (importType.IsGenericType)
{
importType = importType.GetGenericArguments()[0];
}
else if (importType.IsArray)
{
importType = importType.GetElementType();
}
}
if (!(importType.IsGenericType &&
importType.GetGenericTypeDefinition() == typeof(ExportFactory <>) ||
importType.GetGenericTypeDefinition() == typeof(ExportFactory <,>)))
{
throw new NotSupportedException("Import type not supported.");
}
return(importType);
}
/// <summary>
/// Gets all the exports that match the constraint defined by the specified definition.
/// </summary>
/// <param name="definition">The object that defines the conditions of the
/// System.ComponentModel.Composition.Primitives.Export objects to return.</param>
/// <param name="atomicComposition">The transactional container for the composition.</param>
/// <returns>A collection that contains all the exports that match the specified condition.</returns>
protected override IEnumerable <Export> GetExportsCore(
ImportDefinition definition,
AtomicComposition atomicComposition)
{
var contractName = definition.ContractName;
var nothingToDo =
string.IsNullOrEmpty(contractName) || // no contract
(definition.Cardinality != ImportCardinality.ZeroOrOne &&
definition.Cardinality != ImportCardinality.ExactlyOne); // we only support single value cardinalities
if (nothingToDo)
{
yield break;
}
if (this.configurationSource.ContainsSetting(contractName))
{
// import was found to be an app setting - may need to convert it to an appropriate type for the importer
Type targetType = null;
string stringValue = null;
if (ReflectionModelServices.IsImportingParameter(definition))
{
// import appears on a parameter
var importingParameter = ReflectionModelServices.GetImportingParameter(definition);
targetType = importingParameter.Value.ParameterType;
stringValue = this.configurationSource.GetSetting(contractName);
}
else
{
// import appears on a member (property)
var getAccessor = ReflectionModelServices
.GetImportingMember(definition)
.GetAccessors()
.Where(x => x is MethodInfo)
.Select(x => x as MethodInfo)
.FirstOrDefault(x => (x.Attributes & MethodAttributes.SpecialName) == MethodAttributes.SpecialName && x.Name.StartsWith("get_", StringComparison.Ordinal));
if (getAccessor == null)
{
// cannot determine type of importing property
yield break;
}
targetType = getAccessor.ReturnType;
stringValue = this.configurationSource.GetSetting(contractName);
}
if (targetType == null)
{
yield break;
}
var export = new Export(contractName, () => Convert.ChangeType(stringValue, targetType));
yield return(export);
}
else if (this.configurationSource.ContainsSection(contractName))
{
// import was found to be a configuration section
var section = this.configurationSource.GetSection(contractName);
yield return(new Export(contractName, () => section));
}
}