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;
}
public ImportingMember(ContractBasedImportDefinition definition, ReflectionWritableMember member, ImportType importType)
: base(definition, importType)
{
Assumes.NotNull(definition, member);
this._member = member;
}
protected ImportingItem(ContractBasedImportDefinition definition, ImportType importType)
{
Assumes.NotNull(definition);
this._definition = definition;
this._importType = importType;
}
/// <summary>
/// Gets teh ViewModel export
/// </summary>
/// <param name="vmContractName">The contract for the view model to get</param>
/// <returns></returns>
public Export GetViewModelByContract(string vmContractName)
{
if (_container == null)
{
// try getting the container again
_container = LocatorBootstrapper.EnsureLocatorBootstrapper();
}
var viewModelTypeIdentity = AttributedModelServices.GetTypeIdentity(typeof(object));
var requiredMetadata = new Dictionary<string, Type>();
requiredMetadata[ExportViewModel.NameProperty] = typeof(string);
requiredMetadata[ExportViewModel.ContextAwareServicesProperty] = typeof(IEnumerable<Type>);
requiredMetadata[ExportViewModel.IsDataContextAwareProperty] = typeof(bool);
var definition = new ContractBasedImportDefinition(ExportViewModel.Contract, viewModelTypeIdentity,
requiredMetadata, ImportCardinality.ZeroOrMore, false,
false, CreationPolicy.NonShared);
var vmExports = _container.GetExports(definition);
var vmExport = vmExports.Single(e => e.Metadata[ExportViewModel.NameProperty].Equals(vmContractName));
if (vmExport != null)
return vmExport;
return null;
}
private static ImportDefinition TranslateImport(ImportDefinition import, ComposablePartDefinition part)
{
ContractBasedImportDefinition contractBasedImport = import as ContractBasedImportDefinition;
if (contractBasedImport == null)
{
return(import);
}
int[] importParametersOrder = contractBasedImport.Metadata.GetValue <int[]>(CompositionConstants.GenericImportParametersOrderMetadataName);
if (importParametersOrder == null)
{
return(import);
}
int partArity = part.Metadata.GetValue <int>(CompositionConstants.GenericPartArityMetadataName);
if (partArity == 0)
{
return(import);
}
string contractName = GenericServices.GetGenericName(contractBasedImport.ContractName, importParametersOrder, partArity);
string requiredTypeIdentity = GenericServices.GetGenericName(contractBasedImport.RequiredTypeIdentity, importParametersOrder, partArity);
return(new ContractBasedImportDefinition(
contractName,
requiredTypeIdentity,
contractBasedImport.RequiredMetadata,
contractBasedImport.Cardinality,
contractBasedImport.IsRecomposable,
false,
contractBasedImport.RequiredCreationPolicy,
contractBasedImport.Metadata));
}
public object GetInstance(Type serviceType, InstanceContext instanceContext, Message message)
{
var contract = AttributedModelServices.GetContractName(serviceType);
var identity = AttributedModelServices.GetTypeIdentity(serviceType);
var definition = new ContractBasedImportDefinition(contract, identity, null, ImportCardinality.ExactlyOne, false,
false, CreationPolicy.NonShared);
return _container.GetExports(definition).First().Value;
}
// Get the instance from MEF
public object GetInstance(Type serviceType, InstanceContext instanceContext, HttpRequestMessage message)
{
var contract = AttributedModelServices.GetContractName(serviceType);
var identity = AttributedModelServices.GetTypeIdentity(serviceType);
// force non-shared so that every service doesn't need to have a [PartCreationPolicy] attribute.
var definition = new ContractBasedImportDefinition(contract, identity, null, ImportCardinality.ExactlyOne, false, false, CreationPolicy.NonShared);
return this.container.GetExports(definition).First().Value;
}
public PartCreatorMemberImportDefinition(
LazyMemberInfo importingLazyMember,
ICompositionElement origin,
ContractBasedImportDefinition productImportDefinition)
: base(importingLazyMember, CompositionConstants.PartCreatorContractName, CompositionConstants.PartCreatorTypeIdentity,
productImportDefinition.RequiredMetadata, productImportDefinition.Cardinality, productImportDefinition.IsRecomposable, CreationPolicy.Any, origin)
{
Assumes.NotNull(productImportDefinition);
this._productImportDefinition = productImportDefinition;
}
/// <summary>
/// Create an UnsuitableExportDefinitionInfo.
/// </summary>
/// <param name="target">Import for which the export is unsuitable.</param>
/// <param name="exportDefinition">Unsuitable export.</param>
/// <param name="partDefinition">Part definition that provided the export.</param>
public UnsuitableExportDefinitionInfo(
ContractBasedImportDefinition target,
ExportDefinition exportDefinition,
PartDefinitionInfo partDefinition)
{
ExportDefinition = exportDefinition;
PartDefinition = partDefinition;
_issues = CheckForRequiredMetadataIssues(target, exportDefinition)
.Concat(CheckForTypeIdentityIssues(target, exportDefinition))
.Concat(CheckForCreationPolicyIssues(target, partDefinition.PartDefinition))
.ToArray();
}
public static bool ShouldCreateClosedGenericPart(ContractBasedImportDefinition definition, Type importDefinitionType)
{
if (definition == null)
{
throw new ArgumentNullException("definition");
}
if (importDefinitionType == null)
{
throw new ArgumentNullException("importDefinitionType");
}
return definition.Cardinality != ImportCardinality.ZeroOrMore && importDefinitionType.IsGenericType;
}
public static IEnumerable<object> GetExportedValuesByType(this CompositionContainer container, Type type)
{
foreach (var PartDef in container.Catalog.Parts)
{
foreach (var ExportDef in PartDef.ExportDefinitions)
{
if (ExportDef.ContractName == type.FullName)
{
var contract = AttributedModelServices.GetContractName(type);
var definition = new ContractBasedImportDefinition(contract, contract, null, ImportCardinality.ExactlyOne,
false, false, CreationPolicy.Any);
return container.GetExports(definition);
}
}
}
return new List<object>();
}
public Export GetServiceByContract(Type serviceType)
{
if (_container == null)
{
// try getting the container again
_container = LocatorBootstrapper.EnsureLocatorBootstrapper();
}
var serviceTypeIdentity = AttributedModelServices.GetTypeIdentity(serviceType);
var requiredMetadata = new Dictionary<string, Type>();
requiredMetadata[ExportService.IsDesignTimeServiceProperty] = typeof(ServiceType);
requiredMetadata[ExportService.ServiceContractProperty] = typeof(Type);
var definition = new ContractBasedImportDefinition(serviceTypeIdentity, serviceTypeIdentity,
requiredMetadata, ImportCardinality.ZeroOrMore, false,
false, CreationPolicy.NonShared);
var vmExport = _container.GetExports(definition).FirstOrDefault();
if (vmExport != null)
return vmExport;
return null;
}
static IEnumerable<UnsuitableExportDefinitionIssue> CheckForCreationPolicyIssues(ContractBasedImportDefinition cbid, ComposablePartDefinition pd)
{
if (cbid.RequiredCreationPolicy != CreationPolicy.Any)
{
object actual;
if (pd.Metadata.TryGetValue(CompositionConstants.PartCreationPolicyMetadataName, out actual) &&
actual != null)
{
if (actual is CreationPolicy && !actual.Equals(cbid.RequiredCreationPolicy))
{
yield return new UnsuitableExportDefinitionIssue(
UnsuitableExportDefinitionReason.CreationPolicy,
string.Format("The import requires creation policy '{0}', but the exporting part only supports '{1}'.",
cbid.RequiredCreationPolicy, actual));
}
else
{
yield return new UnsuitableExportDefinitionIssue(
UnsuitableExportDefinitionReason.CreationPolicy,
string.Format("The metadata stored for creation policy should be of type CreationPolicy, but is '{0}'.", actual.GetType()));
}
}
}
}
/// <summary>
/// Gets teh ViewModel export
/// </summary>
/// <param name="vmContractName">The contract for the view model to get</param>
/// <returns></returns>
public Export GetViewModelByContract(string vmContractName, object contextToInject)
{
if(Container == null)
return null;
var viewModelTypeIdentity = AttributedModelServices.GetTypeIdentity(typeof(object));
var requiredMetadata = new Dictionary<string, Type>();
requiredMetadata[ExportViewModel.NameProperty] = typeof(string);
requiredMetadata[ExportViewModel.IsDataContextAwareProperty] = typeof(bool);
var definition = new ContractBasedImportDefinition(vmContractName, viewModelTypeIdentity,
requiredMetadata, ImportCardinality.ZeroOrMore, false,
false, CreationPolicy.Any);
SetContextToExportProvider(contextToInject);
var vmExports = Container.GetExports(definition);
SetContextToExportProvider(null);
var vmExport = vmExports.FirstOrDefault(e => e.Metadata[ExportViewModel.NameProperty].Equals(vmContractName));
if (vmExport != null)
return vmExport;
return null;
}
private IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> GetExports(ContractBasedImportDefinition definition)
{
ComposablePartDefinition[] matchingParts = this.GetPartsWithContract(definition.ContractName);
if (matchingParts == null)
{
return Enumerable.Empty<Tuple<ComposablePartDefinition, ExportDefinition>>();
}
else
{
var exports = new List<Tuple<ComposablePartDefinition, ExportDefinition>>();
foreach (var part in matchingParts)
{
foreach (var export in part.ExportDefinitions)
{
if (definition.IsConstraintSatisfiedBy(export))
{
exports.Add(new Tuple<ComposablePartDefinition, ExportDefinition>(part, export));
}
}
}
return exports;
}
}
private static IEnumerable<UnsuitableExportDefinitionIssue> CheckForTypeIdentityIssues(
ContractBasedImportDefinition cbid, ExportDefinition ped)
{
if (cbid.RequiredTypeIdentity != null)
{
object actual;
if (ped.Metadata.TryGetValue(
CompositionConstants.ExportTypeIdentityMetadataName, out actual) &&
actual != null)
{
var actualString = actual as string;
if (actualString == null)
{
yield return new UnsuitableExportDefinitionIssue(
UnsuitableExportDefinitionReason.TypeIdentity,
string.Format("ExportTypeIdentity is provided, but the metadata value is a '{0}'. The value should be a string.",
actual.GetType()));
}
else if (cbid.RequiredTypeIdentity != actualString)
{
yield return new UnsuitableExportDefinitionIssue(
UnsuitableExportDefinitionReason.TypeIdentity,
string.Format("The export is a '{0}', but the import requires '{1}'. These types must match exactly (conversions are not supported.)",
actualString, cbid.RequiredTypeIdentity));
}
}
else
{
yield return new UnsuitableExportDefinitionIssue(
UnsuitableExportDefinitionReason.TypeIdentity,
string.Format("Import requires '{0}', but export does not provide type information. This should be stored in ExportDefinition.Metadata[{1}].",
cbid.RequiredTypeIdentity, CompositionConstants.ExportTypeIdentityMetadataName));
}
}
}
private static IEnumerable<UnsuitableExportDefinitionIssue> CheckForRequiredMetadataIssues(
ContractBasedImportDefinition cbid, ExportDefinition ped)
{
var missing = cbid
.RequiredMetadata
.Where(rm => !ped.Metadata.ContainsKey(rm.Key))
.Select(rm => new UnsuitableExportDefinitionIssue(
UnsuitableExportDefinitionReason.RequiredMetadata,
string.Format("The import requires metadata '{0}' but this is not provided by the export.", rm)));
var typeMismatch = cbid
.RequiredMetadata
.Join(
ped.Metadata,
rm => rm.Key,
m => m.Key,
(rm, m) => new { Key = rm.Key, RequiredType = rm.Value, Actual = m.Value })
.Where(info => info.Actual != null && !info.RequiredType.IsAssignableFrom(info.Actual.GetType()))
.Select(info => new UnsuitableExportDefinitionIssue(
UnsuitableExportDefinitionReason.RequiredMetadata,
string.Format("The import requires metadata '{0}' to be of type '{1}' but the provided value '{2}' is of type '{3}'",
info.Key, info.RequiredType, info.Actual, info.Actual.GetType())));
return missing.Concat(typeMismatch);
}
public ImportingParameter(ContractBasedImportDefinition definition, ImportType importType)
: base(definition, importType)
{
}
public void Constructor2_ValueAsRequiredMetadataArgument_ShouldSetRequiredMetadataProperty()
{
var expectations = Expectations.GetRequiredMetadataWithEmpty();
foreach (var e in expectations)
{
var definition = new ContractBasedImportDefinition("ContractName", (string)null, e, ImportCardinality.ExactlyOne, false, false, CreationPolicy.Any);
EnumerableAssert.AreEqual(e, definition.RequiredMetadata);
}
}
public void ApplicationCatalog(Type contractType, bool expectedIsDisposableNormal, bool expectedIsDisposableWrapped)
{
// ApplicationCatalog is a good comprehensive test because it uses the following hierarchy:
// + AggregateCatalog
// + DirectoryCatalog
// + AssemblyCatalog
// + TypeCatalog
using (var innerCatalog = new ApplicationCatalog())
using (var wrapperCatalog = new DisposableWrapperCatalog(innerCatalog, false))
{
const ImportCardinality cardinality = ImportCardinality.ExactlyOne;
var metadata = new Dictionary<string, object>();
var typeIdentity = AttributedModelServices.GetTypeIdentity(contractType);
var contractName = AttributedModelServices.GetContractName(contractType);
var definition = new ContractBasedImportDefinition(contractName, typeIdentity, null, cardinality, false, true, CreationPolicy.Any, metadata);
var partNormal = innerCatalog.GetExports(definition).Single().Item1.CreatePart();
var partWrapped = wrapperCatalog.GetExports(definition).Single().Item1.CreatePart();
var isDisposableNormal = partNormal is IDisposable;
var isDisposableWrapped = partWrapped is IDisposable;
Assert.AreEqual(expectedIsDisposableNormal, isDisposableNormal, "Checking Normal Part");
Assert.AreEqual(expectedIsDisposableWrapped, isDisposableWrapped, "Checking Wrapped Part");
}
}
public static bool ShouldCreateClosedGenericPart(ContractBasedImportDefinition contractDef, Type importDefinitionType)
{
return contractDef.Cardinality != ImportCardinality.ZeroOrMore && importDefinitionType.IsGenericType;
}
public void RequiredMetadata_ArrayWithNullKeyAsRequiredMetadataArgument_ShouldThrowInvalidOperation()
{
var requiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>(null, typeof(object)) };
var import = new ContractBasedImportDefinition("requiredMetadata", (string)null, requiredMetadata, ImportCardinality.ExactlyOne, false, false, CreationPolicy.Any);
ExceptionAssert.Throws<InvalidOperationException>(() =>
{
var m = import.RequiredMetadata;
});
}
public void Constraint_ShouldIncludeRequiredMetadataProperty()
{
var expectations = Expectations.GetRequiredMetadataWithEmpty();
foreach (var e in expectations)
{
var definition = new ContractBasedImportDefinition("ContractName", (string)null, e, ImportCardinality.ExactlyOne, true, false, CreationPolicy.Any);
ConstraintAssert.Contains(definition.Constraint, "ContractName", e);
}
}
public void Constructor2_NullAsRequiredMetadataArgument_ShouldSetRequiredMetadataToEmptyEnumerable()
{
var definition = new ContractBasedImportDefinition("requiredMetadata", (string)null, (IEnumerable<KeyValuePair<string, Type>>)null, ImportCardinality.ExactlyOne, false, false, CreationPolicy.Any);
EnumerableAssert.IsEmpty(definition.RequiredMetadata);
}
public void Constructor2_ShouldSetRequiredCreationPolicyToAny()
{
var expectations = Expectations.GetEnumValues<CreationPolicy>();
foreach (var e in expectations)
{
var definition = new ContractBasedImportDefinition("ContractName", (string)null, Enumerable.Empty<KeyValuePair<string, Type>>(), ImportCardinality.ExactlyOne, false, false, e);
Assert.AreEqual(e, definition.RequiredCreationPolicy);
}
}
public void Constructor2_ValueAsIsPrerequisiteArgument_ShouldSetIsPrerequisiteProperty()
{
var expectations = Expectations.GetBooleans();
foreach (var e in expectations)
{
var definition = new ContractBasedImportDefinition("ContractName", (string)null, Enumerable.Empty<KeyValuePair<string, Type>>(), ImportCardinality.ExactlyOne, false, e, CreationPolicy.Any);
Assert.AreEqual(e, definition.IsPrerequisite);
}
}
public static ContractBasedImportDefinition CreateExportFactoryImportDefinition(ContractBasedImportDefinition productImportDefinition)
{
return new ExportFactoryImportDefinition(productImportDefinition);
}
private IDictionary<string, object> TranslateImportMetadata(ContractBasedImportDefinition originalImport)
{
int[] importParametersOrder = originalImport.Metadata.GetValue<int[]>(CompositionConstants.GenericImportParametersOrderMetadataName);
if (importParametersOrder != null)
{
Dictionary<string, object> metadata = new Dictionary<string, object>(originalImport.Metadata, StringComparers.MetadataKeyNames);
// Get the newly re-qualified name of the generic contract and the subset of applicable types from the specialization
metadata[CompositionConstants.GenericContractMetadataName] = GenericServices.GetGenericName(originalImport.ContractName, importParametersOrder, this._specialization.Length);
metadata[CompositionConstants.GenericParametersMetadataName] = GenericServices.Reorder(this._specialization, importParametersOrder);
metadata.Remove(CompositionConstants.GenericImportParametersOrderMetadataName);
return metadata.AsReadOnly();
}
else
{
return originalImport.Metadata;
}
}
public ExportFactoryImportDefinition(ContractBasedImportDefinition productImportDefinition)
: base(CompositionConstants.PartCreatorContractName, CompositionConstants.PartCreatorTypeIdentity, productImportDefinition.RequiredMetadata,
productImportDefinition.Cardinality, productImportDefinition.IsRecomposable, false, CreationPolicy.Any)
{
_productImportDefinition = productImportDefinition;
}
public void Constraint_ShouldIncludeContractNameProperty()
{
var expectations = Expectations.GetContractNames();
foreach (var e in expectations)
{
var definition = new ContractBasedImportDefinition(e, (string)null, (IEnumerable<KeyValuePair<string, Type>>)null, ImportCardinality.ExactlyOne, true, false, CreationPolicy.Any);
ConstraintAssert.Contains(definition.Constraint, e);
}
}
public void Constructor2_ValueAsCardinalityArgument_ShouldSetCardinalityProperty()
{
var expectations = Expectations.GetEnumValues<ImportCardinality>();
foreach (var e in expectations)
{
var definition = new ContractBasedImportDefinition("ContractName", (string)null, Enumerable.Empty<KeyValuePair<string, Type>>(), e, false, false, CreationPolicy.Any);
Assert.AreEqual(e, definition.Cardinality);
}
}