public void PartCreatorConstraint_ShouldMatchPartCreatorExportDefinition()
{
var partCreatorImportDef = ReflectionModelServices.CreateImportDefinition(
new LazyMemberInfo(MemberTypes.Field, () => new MemberInfo[] { typeof(ConstraintServicesTests) }),
"Foo",
"Foo",
new KeyValuePair <string, Type>[] { new KeyValuePair <string, Type>("MDKey", typeof(string)) },
ImportCardinality.ZeroOrMore,
false,
CreationPolicy.Any,
true, // IsPartCreator
null);
var metadata = new Dictionary <string, object>();
metadata["MDKey"] = "MDValue";
metadata[CompositionConstants.ExportTypeIdentityMetadataName] = "Foo";
var productExportDefinition = new ExportDefinition("Foo", metadata);
metadata = new Dictionary <string, object>(metadata);
metadata[CompositionConstants.ExportTypeIdentityMetadataName] = CompositionConstants.PartCreatorTypeIdentity;
metadata[CompositionConstants.ProductDefinitionMetadataName] = productExportDefinition;
var exportDefinition = new ExportDefinition(CompositionConstants.PartCreatorContractName, metadata);
var predicate = partCreatorImportDef.Constraint.Compile();
Assert.IsTrue(partCreatorImportDef.IsConstraintSatisfiedBy(exportDefinition));
Assert.IsTrue(predicate(exportDefinition));
}
static IEnumerable <ImportDefinition> GetImportDefinitions(Type implementationType)
{
var constructors = implementationType.GetConstructors()[0];
var imports = new List <ImportDefinition>();
foreach (var param in constructors.GetParameters())
{
var parameter = param;
var cardinality = GetCardinality(parameter);
var importType = cardinality == ImportCardinality.ZeroOrMore
? GetCollectionContractType(parameter.ParameterType)
: param.ParameterType;
imports.Add(
ReflectionModelServices.CreateImportDefinition(
new Lazy <ParameterInfo>(() => parameter),
AttributedModelServices.GetContractName(importType),
AttributedModelServices.GetTypeIdentity(importType),
Enumerable.Empty <KeyValuePair <string, Type> >(),
cardinality,
CreationPolicy.Any,
null)
);
}
return(imports);
}
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));
}
}
/// <summary>
/// Gets an <see cref="ImportDefinition"/> for a <see cref="MemberInfo"/> instance using the provided <see cref="IImportConvention"/> instance.
/// </summary>
/// <param name="importConvention"><see cref="IImportConvention"/> instances that should be used to create the <see cref="ImportDefinition"/> instances.</param>
/// <param name="member">The <see cref="MemberInfo"/> for which the <see cref="ImportDefinition"/> instances should be created.</param>
/// <returns>An <see cref="ImportDefinition"/> instance.</returns>
private ImportDefinition GetImportDefinition(IImportConvention importConvention, MemberInfo member)
{
return(ReflectionModelServices.CreateImportDefinition(
member.ToLazyMemberInfo(),
this.ContractService.GetImportContractName(importConvention, member),
this.ContractService.GetImportTypeIdentity(importConvention, member),
importConvention.RequiredMetadata.Select(x => new KeyValuePair <string, Type>(x.Name, x.Type)),
member.GetCardinality(importConvention.AllowDefaultValue),
importConvention.Recomposable,
importConvention.CreationPolicy,
null));
}
/// <summary>
/// Gets an <see cref="ImportDefinition"/> for a <see cref="ParameterInfo"/> instance using the provided <see cref="IImportConvention"/> instance.
/// </summary>
/// <param name="importConvention"><see cref="IImportConvention"/> instances that should be used to create the <see cref="ImportDefinition"/> instances.</param>
/// <param name="parameter">The <see cref="ParameterInfo"/> for which the <see cref="ImportDefinition"/> instances should be created.</param>
/// <returns>An <see cref="ImportDefinition"/> instance.</returns>
private ImportDefinition GetImportParameterDefinition(IImportConvention importConvention, ParameterInfo parameter)
{
var actualType =
parameter.ParameterType.GetActualType();
return(ReflectionModelServices.CreateImportDefinition(
new Lazy <ParameterInfo>(() => parameter),
this.ContractService.GetImportContractName(importConvention, actualType),
this.ContractService.GetImportTypeIdentity(importConvention, actualType),
null,
parameter.ParameterType.GetCardinality(importConvention.AllowDefaultValue),
importConvention.CreationPolicy,
null));
}
public void PartCreator_QueryContainerDirectly_ShouldWork()
{
var container = ContainerFactory.CreateWithAttributedCatalog(typeof(Foo));
var importDef = ReflectionModelServices.CreateImportDefinition(
new LazyMemberInfo(MemberTypes.Field, () => new MemberInfo[] { typeof(PartCreatorTests) }), // Give it a bogus member
AttributedModelServices.GetContractName(typeof(Foo)),
AttributedModelServices.GetTypeIdentity(typeof(Foo)),
Enumerable.Empty <KeyValuePair <string, Type> >(),
ImportCardinality.ZeroOrMore,
true,
CreationPolicy.Any,
true, // isPartCreator
null);
var exports = container.GetExports(importDef);
var partCreator = exports.Single();
// Manually walk the steps of using a raw part creator which is modeled as a PartDefinition with
// a single ExportDefinition.
var partDef = (ComposablePartDefinition)partCreator.Value;
var part = partDef.CreatePart();
var foo = (Foo)part.GetExportedValue(partDef.ExportDefinitions.Single());
Assert.IsNotNull(foo);
var foo1 = (Foo)part.GetExportedValue(partDef.ExportDefinitions.Single());
Assert.AreEqual(foo, foo1, "Retrieving the exported value from the same part should return the same value");
// creating a new part should result in getting a new exported value
var part2 = partDef.CreatePart();
var foo2 = (Foo)part2.GetExportedValue(partDef.ExportDefinitions.Single());
Assert.AreNotEqual(foo, foo2, "New part should equate to a new exported value");
// Disposing of part should cause foo to be disposed
((IDisposable)part).Dispose();
Assert.IsTrue(foo.IsDisposed);
}
private IEnumerable <ImportDefinition> GetImportDefinitions(Type implementationType)
{
var imports = new List <ImportDefinition>();
var defaultConstructor = implementationType.GetConstructors().FirstOrDefault();
if (defaultConstructor != null)
{
foreach (var param in defaultConstructor.GetParameters())
{
imports.Add(
ReflectionModelServices.CreateImportDefinition(
new Lazy <ParameterInfo>(() => param),
AttributedModelServices.GetContractName(param.ParameterType),
AttributedModelServices.GetTypeIdentity(param.ParameterType),
Enumerable.Empty <KeyValuePair <string, Type> >(),
ImportCardinality.ExactlyOne,
CreationPolicy.Any,
null));
}
}
return(imports);
}
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);
}
internal static ImportDefinition CreateImportDefinition(SerializableImportDefinition serializableImportDefinition)
{
if (serializableImportDefinition.ImportingMember.MemberType == MemberTypes.Constructor)
{
var lazyParameter = new Lazy <ParameterInfo>(() =>
{
Type declaringType = Type.GetType(serializableImportDefinition.ImportingMember.DeclaringTypeAssemblyQualifiedName);
return(MefUtils.GetImportingConstructor(declaringType).GetParameters().Single(x => x.Name == serializableImportDefinition.ImportingMember.MemberName));
});
return(ReflectionModelServices.CreateImportDefinition(
lazyParameter,
serializableImportDefinition.ContractName,
serializableImportDefinition.RequiredTypeIdentity,
serializableImportDefinition.RequiredMetadata.Select(kvp => new KeyValuePair <string, Type>(kvp.Key, Type.GetType(kvp.Value))),
serializableImportDefinition.Cardinality,
serializableImportDefinition.RequiredCreationPolicy,
serializableImportDefinition.Metadata,
serializableImportDefinition.IsExportFactory,
null)); // TODO: Is it OK to have null for origin?
}
else
{
return(ReflectionModelServices.CreateImportDefinition(
CreateLazyMemberInfo(serializableImportDefinition.ImportingMember),
serializableImportDefinition.ContractName,
serializableImportDefinition.RequiredTypeIdentity,
serializableImportDefinition.RequiredMetadata.Select(kvp => new KeyValuePair <string, Type>(kvp.Key, Type.GetType(kvp.Value))),
serializableImportDefinition.Cardinality,
serializableImportDefinition.IsRecomposable,
serializableImportDefinition.IsPrerequisite,
serializableImportDefinition.RequiredCreationPolicy,
serializableImportDefinition.Metadata,
serializableImportDefinition.IsExportFactory,
null)); // TODO: Is it OK to have null for origin?
}
}
public static ContractBasedImportDefinition ReadImportDefinition(ComposablePartDefinition owner, IDictionary <string, object> cache)
{
Assumes.NotNull(owner);
Assumes.NotNull(cache);
Lazy <Type> partType = ReflectionModelServices.GetPartType(owner);
ICompositionElement origin = owner as ICompositionElement;
if (cache.ReadValue <string>(AttributedCacheServices.CacheKeys.ImportType) == AttributedCacheServices.ImportTypes.Parameter)
{
return(ReflectionModelServices.CreateImportDefinition(
cache.ReadLazyParameter(partType),
cache.ReadContractName(),
cache.ReadValue <string>(AttributedCacheServices.CacheKeys.RequiredTypeIdentity),
cache.ReadRequiredMetadata(),
cache.ReadValue <ImportCardinality>(AttributedCacheServices.CacheKeys.Cardinality, ImportCardinality.ExactlyOne),
cache.ReadValue <CreationPolicy>(AttributedCacheServices.CacheKeys.RequiredCreationPolicy, CreationPolicy.Any),
origin));
}
else
{
LazyMemberInfo importingMemberInfo = new LazyMemberInfo(
cache.ReadValue <MemberTypes>(AttributedCacheServices.CacheKeys.MemberType, MemberTypes.Property),
cache.ReadLazyAccessors(partType));
return(ReflectionModelServices.CreateImportDefinition(
importingMemberInfo,
cache.ReadContractName(),
cache.ReadValue <string>(AttributedCacheServices.CacheKeys.RequiredTypeIdentity),
cache.ReadRequiredMetadata(),
cache.ReadValue <ImportCardinality>(AttributedCacheServices.CacheKeys.Cardinality, ImportCardinality.ExactlyOne),
cache.ReadValue <bool>(AttributedCacheServices.CacheKeys.IsRecomposable, false),
cache.ReadValue <CreationPolicy>(AttributedCacheServices.CacheKeys.RequiredCreationPolicy, CreationPolicy.Any),
origin));
}
}