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)); } }