private ExportDefinition CreateWrapped(ExportDefinition export, Type type) { return(ReflectionModelServices.CreateExportDefinition( this.CreateWrapped(ReflectionModelServices.GetExportingMember(export), type), export.ContractName, export.Metadata.AsLazy(), null)); }
internal static ExportDefinition CreateExportDefinition(SerializableExportDefinition serializableExportDefinition) { return(ReflectionModelServices.CreateExportDefinition( CreateLazyMemberInfo(serializableExportDefinition.ExportingMember), serializableExportDefinition.ContractName, new Lazy <IDictionary <string, object> >(() => serializableExportDefinition.Metadata), null)); // TODO: Is it OK to have null for origin? }
public static T GetExport <T>(this object obj, string propertyName, string contractName) { LazyMemberInfo info = new LazyMemberInfo(obj.GetType().GetProperty(propertyName)); var ed = ReflectionModelServices.CreateExportDefinition(info, contractName, null, null); var ed1 = ReflectionModelServices.GetExportingMember(ed); T someService = (T)(ed1.GetAccessors().GetValue(0) as System.Reflection.MethodInfo).Invoke(obj, null); return((T)someService); }
/// <summary> /// Creates <see cref="ExportDefinition"/> instance from the provided <see cref="IExportConvention"/> instances and type. /// </summary> /// <param name="exportConventions">An <see cref="IEnumerable{T}"/> of <see cref="IExportConvention"/> instances that should be used to create the <see cref="ExportDefinition"/> instances.</param> /// <param name="type">The <see cref="Type"/> for which the <see cref="ExportDefinition"/> instances should be created.</param> /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="ExportDefinition"/> instances.</returns> private IEnumerable <ExportDefinition> CreateExportDefinitions(IEnumerable <IExportConvention> exportConventions, Type type) { var exportDefinitionsFromConvention = from exportConvention in exportConventions from member in exportConvention.Members.Invoke(type) select ReflectionModelServices.CreateExportDefinition( member.ToLazyMemberInfo(), this.ContractService.GetExportContractName(exportConvention, member), new Lazy <IDictionary <string, object> >(() => GetExportDefinitionMetadata(exportConvention, member)), null); return(exportDefinitionsFromConvention.ToList()); }
private static ExportDefinition CreateExportDefinition(string contractName, Type type) { LazyMemberInfo memberInfo = new LazyMemberInfo(MemberTypes.TypeInfo, type); Lazy <IDictionary <string, object> > metadata = new Lazy <IDictionary <string, object> >(() => { string typeIdentity = AttributedModelServices.GetTypeIdentity(type); return(new Dictionary <string, object> { { CompositionConstants.ExportTypeIdentityMetadataName, typeIdentity } }); }); ExportDefinition exportDefinition = ReflectionModelServices.CreateExportDefinition(memberInfo, contractName, metadata, null); return(exportDefinition); }
private IEnumerable <ExportDefinition> GetExportDefinitions(Type implementationType, Type contractType) { var lazyMember = new LazyMemberInfo(implementationType); var contracName = AttributedModelServices.GetContractName(contractType); var metadata = new Lazy <IDictionary <string, object> >(() => { var md = new Dictionary <string, object>(); md.Add(CompositionConstants.ExportTypeIdentityMetadataName, AttributedModelServices.GetTypeIdentity(contractType)); return(md); }); return(new [] { ReflectionModelServices.CreateExportDefinition(lazyMember, contracName, metadata, null) }); }
private void RewriteContract(Type typeToDecorate, IList <ExportDefinition> exportDefs, Type exportingType, string newContract) { var exportToDecorate = exportDefs.Single(d => d.ContractName == myContractName); Contract.Requires(exportToDecorate != null, "No import found for contract {0} on type {1}", myContractName, typeToDecorate); exportDefs.Remove(exportToDecorate); var exportDef = ReflectionModelServices.CreateExportDefinition( new LazyMemberInfo(exportingType), newContract, new Lazy <IDictionary <string, object> >(() => exportToDecorate.Metadata), null); exportDefs.Add(exportDef); }
public static ExportDefinition ReadExportDefinition(ComposablePartDefinition owner, IDictionary <string, object> cache) { Assumes.NotNull(owner); Assumes.NotNull(cache); LazyMemberInfo exportingMemberInfo = new LazyMemberInfo( cache.ReadValue <MemberTypes>(AttributedCacheServices.CacheKeys.MemberType, MemberTypes.TypeInfo), cache.ReadLazyAccessors(ReflectionModelServices.GetPartType(owner))); return(ReflectionModelServices.CreateExportDefinition( exportingMemberInfo, cache.ReadContractName(), cache.ReadLazyMetadata(), owner as ICompositionElement)); }
public AddInComposablePartDefinition(AddInCatalog catalog, ComposablePartDefinition composablePartDefinition) { this._composablePartDefinition = composablePartDefinition; List <KeyValuePair <string, object> > injectedMetadata = new List <KeyValuePair <string, object> >(); injectedMetadata.Add(new KeyValuePair <string, object>(AddInCatalog.PackageIdMetadataName, catalog.PackageId)); injectedMetadata.Add(new KeyValuePair <string, object>(AddInCatalog.PackageVersionMetadataName, catalog.PackageVersion)); List <ExportDefinition> interceptedExports = new List <ExportDefinition>(); foreach (ExportDefinition export in composablePartDefinition.ExportDefinitions) { ICompositionElement compositionElement = export as ICompositionElement; if (compositionElement == null) { throw new InvalidOperationException("ExportDefinition doesn't implement ICompositionElement"); } Dictionary <string, object> metadata = injectedMetadata.Concat(export.Metadata) .ToDictionary(kvp => kvp.Key, kvp => kvp.Value); // TODO this will fail if export isn't a ReflectionMemberExportDefinition (Internal, so I can't check) LazyMemberInfo lazyMember = ReflectionModelServices.GetExportingMember(export); ExportDefinition interceptedExport = ReflectionModelServices.CreateExportDefinition(lazyMember, export.ContractName, new Lazy <IDictionary <string, object> >(() => metadata), compositionElement.Origin); interceptedExports.Add(interceptedExport); } this._exportDefinitions = interceptedExports.ToArray(); }
private IEnumerable <ComposablePartDefinition> BuildParts(IQueryable <ComposablePartDefinition> parts) { return(parts.Select(def => ReflectionModelServices.CreatePartDefinition( ReflectionModelServices.GetPartType(def), true, new Lazy <IEnumerable <ImportDefinition> >(() => def.ImportDefinitions), new Lazy <IEnumerable <ExportDefinition> >(() => def.ExportDefinitions.Select(export => ReflectionModelServices.CreateExportDefinition( ReflectionModelServices.GetExportingMember(export), export.ContractName, new Lazy <IDictionary <string, object> >(() => VisitExport(def, export)), this))), new Lazy <IDictionary <string, object> >(() => VisitPart(def)), this))); }
private ComposablePartDefinition RewritePart(ComposablePartDefinition definition) { var closedGenericContractType = ContractType.MakeGenericType(ExportingType.GetGenericArguments()); var closedGenericTypeIdentity = AttributedModelServices.GetTypeIdentity(closedGenericContractType); var openGenericTypeIdentity = AttributedModelServices.GetTypeIdentity(ContractType); var openGenericContractName = AttributedModelServices.GetContractName(ContractType); var exports = new List <ExportDefinition>(); var hasRewrittenExports = false; foreach (var exportDefinition in definition.ExportDefinitions) { // Rewrite only exports having open-generics type identity of the contract type we do care about if (openGenericTypeIdentity == (string)exportDefinition.Metadata[CompositionConstants.ExportTypeIdentityMetadataName]) { // If both open-generic contract name and the present contract name are equal, // contract name has to be rewritten to form a closed-generic contract var contractName = openGenericContractName == exportDefinition.ContractName ? AttributedModelServices.GetContractName(closedGenericContractType) : exportDefinition.ContractName; // Preserve all the metadata except the type identity as it has to be rewritten var metadata = new Dictionary <string, object> { { CompositionConstants.ExportTypeIdentityMetadataName, closedGenericTypeIdentity } }; foreach (var key in exportDefinition.Metadata.Keys.Where(key => key != CompositionConstants.ExportTypeIdentityMetadataName)) { metadata.Add(key, exportDefinition.Metadata[key]); } // Rewrite the export var rewrittenExport = ReflectionModelServices.CreateExportDefinition( ReflectionModelServices.GetExportingMember(exportDefinition), contractName, new Lazy <IDictionary <string, object> >(() => metadata), exportDefinition as ICompositionElement); exports.Add(rewrittenExport); hasRewrittenExports = true; } else { // This export is ok, copy the original exports.Add(exportDefinition); } } // If the part has any rewritten exports, we have to rewrite the part itself if (hasRewrittenExports) { return(ReflectionModelServices.CreatePartDefinition( ReflectionModelServices.GetPartType(definition), ReflectionModelServices.IsDisposalRequired(definition), new Lazy <IEnumerable <ImportDefinition> >(() => definition.ImportDefinitions), new Lazy <IEnumerable <ExportDefinition> >(() => exports), new Lazy <IDictionary <string, object> >(() => definition.Metadata), definition as ICompositionElement)); } return(definition); }