public void SatisfyImportsOnce(ComposablePart part)
{
if (this.DoNothingOnSatisfyImportsOnce)
{
return;
}
CompositionBatch batch = new CompositionBatch();
// We only want to include the standard exports and parts to compose in the first composition
if (!this.alreadyComposed)
{
foreach (object instance in this.PartsToCompose)
{
batch.AddPart(instance);
}
foreach (Export export in this.ExportsToCompose)
{
batch.AddExport(export);
}
}
if (part != null)
{
batch.AddPart(part);
}
this.container.Compose(batch);
this.alreadyComposed = true;
}
public void Configure(ApplicationConfigurationBase applicationConfiguration)
{
if (IsConfigured)
return;
// Compose app container
var batch = new CompositionBatch();
foreach (var entry in _Entries)
{
var entryType = entry.GetType();
var contractName = AttributedModelServices.GetContractName(entryType);
var typeIdentity = AttributedModelServices.GetTypeIdentity(entryType);
var metadata = new Dictionary<string, object> { { "ExportTypeIdentity", typeIdentity } };
batch.AddExport(new Export(contractName, metadata, () => entry));
}
applicationConfiguration.CompositionContainer.Compose(batch);
IsConfigured = true;
}
private IEnumerable<UnitOfWork> DiscoverWork(TemplateData templateData, XPathVariable[] parameters, Resource[] resources)
{
CustomXsltContext xpathContext = CreateCustomXsltContext(templateData.IgnoredVersionComponent);
xpathContext.PushVariableScope(templateData.Document.Root, parameters);
for (int i = 0; i < resources.Length; i++)
{
xpathContext.PushVariableScope(templateData.Document.Root, resources[i].Variables);
if (EvalCondition(xpathContext, templateData.Document.Root, resources[i].ConditionExpression))
{
string expandedSource = EvalValue(xpathContext, templateData.Document.Root, resources[i].Source);
string expandedOutput = EvalValue(xpathContext, templateData.Document.Root, resources[i].Output);
List<IResourceTransform> transforms = new List<IResourceTransform>();
foreach (var resourceTransform in resources[i].Transforms)
{
using (CompositionContainer localContainer = new CompositionContainer(this._container.Catalog))
{
string dirName = Path.GetDirectoryName(expandedSource);
CompositionBatch batch = new CompositionBatch();
var exportMetadata = new Dictionary<string, object>();
exportMetadata.Add(CompositionConstants.ExportTypeIdentityMetadataName,
AttributedModelServices.GetTypeIdentity(typeof(IFileProvider)));
exportMetadata.Add(CompositionConstants.PartCreationPolicyMetadataName,
CreationPolicy.Shared);
batch.AddExport(new Export(ContractNames.ResourceFileProvider,
exportMetadata,
() => new ScopedFileProvider(resources[i].FileProvider, dirName)));
// TODO export resourceTransform.Parameters into localContainer using CompositionBatch
localContainer.Compose(batch);
var requiredMetadata = new[]
{
new Tuple<string, object, IEqualityComparer>("Name",
resourceTransform.Name,
StringComparer.OrdinalIgnoreCase)
};
ImportDefinition importDefinition =
new MetadataContractBasedImportDefinition(
typeof(IResourceTransform),
null,
requiredMetadata,
ImportCardinality.ExactlyOne,
false,
true,
CreationPolicy.NonShared);
Export transformExport = localContainer.GetExports(importDefinition).Single();
transforms.Add((IResourceTransform)transformExport.Value);
}
}
yield return
new ResourceDeployment(resources[i].FileProvider,
expandedSource,
expandedOutput, // TODO this needs a 'writable' file provider
transforms.ToArray());
}
xpathContext.PopVariableScope();
}
xpathContext.PopVariableScope();
}
public void InAdditionToCatalogTest()
{
var container = ContainerFactory.CreateWithDefaultAttributedCatalog();
IDictionary<string, object> multMetadata = new Dictionary<string, object>();
multMetadata["Var1"]= "mult";
multMetadata[CompositionConstants.ExportTypeIdentityMetadataName] = AttributedModelServices.GetTypeIdentity(typeof(Func<int, int, int>));
var basicValue = ExportFactory.Create("Add", multMetadata, (() => (Func<int, int, int>)delegate(int a, int b) { return a * b; }));
CompositionBatch batch = new CompositionBatch();
batch.AddExport(basicValue);
container.Compose(batch);
var exports = container.GetExports<Func<int, int, int>, IExportableTest>("Add");
Assert.AreEqual(3, exports.Count(), "There should be 3 entries for 'Add'");
foreach (var export in exports)
{
if (export.Metadata.Var1 == "mult")
{
Assert.AreEqual(2, export.Value(1, 2), "1 * 2 == 2");
}
else if (export.Metadata.Var1 == "add")
{
Assert.AreEqual(3, export.Value(1, 2), "1 + 2 == 3");
}
else if (export.Metadata.Var1 == "sub")
{
Assert.AreEqual(-1, export.Value(1, 2), "1 - 2 == -1");
}
else
{
Assert.Fail("Unexpected value");
}
}
}
