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