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))); } }
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 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); }
/// <summary> /// Gets the <see cref="Type"/> of the given <see cref="ImportDefinition"/>. /// </summary> /// <param name="definition">The <see cref="ImportDefinition"/> instance.</param> /// <returns>A <see cref="Type"/> of the requested import.</returns> /// <remarks>Works only for reflection model import definitions.</remarks> public static Type GetImportDefinitionType(ImportDefinition definition) { if (definition == null) { throw new ArgumentNullException("definition"); } var importDefinitionType = ReflectionModelServices.IsImportingParameter(definition) ? GetParameterType(definition) : GetMethodType(definition); return(importDefinitionType); }
public static Type GetImportDefinitionType(ImportDefinition definition) { Type importDefinitionType = null; if (ReflectionModelServices.IsImportingParameter(definition)) { importDefinitionType = GetParameterType(definition); } else { importDefinitionType = GetMethodType(definition, importDefinitionType); } return(importDefinitionType); }
private static ComposablePartDefinition CreatePartDefinition(IEnumerable <ImportDefinition> ctorImports, ExportDefinition contractExport, Type type) { var originalPartDefinition = AttributedModelServices.CreatePartDefinition(type, null); if (originalPartDefinition == null) { throw new InvalidOperationException(); } var imports = originalPartDefinition.ImportDefinitions .Where(idef => !ReflectionModelServices.IsImportingParameter(idef)) .Concat(ctorImports) .ToList(); var exports = originalPartDefinition.ExportDefinitions.ToList(); exports.Add(contractExport); var metadata = originalPartDefinition.Metadata; return(CreatePartDefinition(type, imports, exports, metadata)); }
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); } } } }
protected override IEnumerable <Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition) { Export export; if (!FExports.TryGetValue(definition, out export)) { var contractName = definition.ContractName; if (contractName == typeof(IIOFactory).FullName) { export = new Export(contractName, () => FIOFactory); } else { var typeToExport = ExportProviderUtils.GetImportDefinitionType(definition); foreach (var attribute in ExportProviderUtils.GetImportDefinitionAttributes(definition)) { var ioAttribute = attribute as IOAttribute; if (ioAttribute == null) { continue; } if (!ReflectionModelServices.IsImportingParameter(definition)) { var member = ReflectionModelServices.GetImportingMember(definition); if (member.MemberType == MemberTypes.Property) { foreach (var accessor in member.GetAccessors()) { if (FAccessorToExportMap.TryGetValue(accessor, out export)) { break; } } } } if (export == null) { var context = IOBuildContext.Create(typeToExport, ioAttribute); if (FIOFactory.CanCreateIOContainer(context)) { export = new Export(contractName, () => FIOFactory.CreateIO(context)); // Now register the export for all the base members if (!ReflectionModelServices.IsImportingParameter(definition)) { var member = ReflectionModelServices.GetImportingMember(definition); if (member.MemberType == MemberTypes.Property) { foreach (var accessor in member.GetAccessors().OfType <MethodInfo>()) { RegisterExport(accessor, export); } } } } } if (export != null) { break; } } } FExports.Add(definition, export); } if (export != null) { yield return(export); } }
/// <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)); } }
private IEnumerable <Tuple <Type, PartDefinition> > ExtractImportsAndExports(Assembly assembly, Func <Type, TypeIdentity> createTypeIdentity) { var catalog = new AssemblyCatalog(assembly); foreach (var part in catalog.Parts) { var exports = new List <SerializableExportDefinition>(); foreach (var export in part.ExportDefinitions) { var memberInfo = ReflectionModelServices.GetExportingMember(export); SerializableExportDefinition exportDefinition = null; switch (memberInfo.MemberType) { case MemberTypes.Method: exportDefinition = CreateMethodExport(export, memberInfo, createTypeIdentity); break; case MemberTypes.Property: exportDefinition = CreatePropertyExport(export, memberInfo, createTypeIdentity); break; case MemberTypes.NestedType: case MemberTypes.TypeInfo: exportDefinition = CreateTypeExport(export, memberInfo, createTypeIdentity); break; default: throw new NotImplementedException(); } if (exportDefinition != null) { exports.Add(exportDefinition); m_Logger.Log( LevelToLog.Info, string.Format( CultureInfo.InvariantCulture, "Discovered export: {0}", exportDefinition)); } else { m_Logger.Log( LevelToLog.Warn, string.Format( CultureInfo.InvariantCulture, "Unable to process export: {0} on a {1}", export.ContractName, memberInfo.MemberType)); } } var imports = new List <SerializableImportDefinition>(); foreach (var import in part.ImportDefinitions) { Debug.Assert(import is ContractBasedImportDefinition, "All import objects should be ContractBasedImportDefinition objects."); var contractImport = import as ContractBasedImportDefinition; SerializableImportDefinition importDefinition = !ReflectionModelServices.IsImportingParameter(contractImport) ? CreatePropertyImport(contractImport, createTypeIdentity) : CreateConstructorParameterImport(contractImport, createTypeIdentity); if (importDefinition != null) { imports.Add(importDefinition); m_Logger.Log( LevelToLog.Info, string.Format( CultureInfo.InvariantCulture, "Discovered import: {0}", importDefinition)); } else { m_Logger.Log( LevelToLog.Warn, string.Format( CultureInfo.InvariantCulture, "Unable to process import: {0}", import.ContractName)); } } var type = ReflectionModelServices.GetPartType(part).Value; yield return(new Tuple <Type, PartDefinition>( type, new PartDefinition { Identity = createTypeIdentity(type), Exports = exports, Imports = imports, Actions = Enumerable.Empty <ScheduleActionDefinition>(), Conditions = Enumerable.Empty <ScheduleConditionDefinition>(), })); } }