public ConstructorInjectionComposablePart(Type type)
{
this._type = type;
// Note that this just blindly takes the first constructor...
this._constructor = this._type.GetConstructors().FirstOrDefault();
Assert.IsNotNull(this._constructor);
foreach (var param in this._constructor.GetParameters())
{
string name = AttributedModelServices.GetContractName(param.ParameterType);
AddImport(name, ImportCardinality.ExactlyOne, true, true);
}
string contractName = AttributedModelServices.GetContractName(type);
string typeIdentity = AttributedModelServices.GetTypeIdentity(type);
var metadata = new Dictionary <string, object>();
metadata.Add(CompositionConstants.ExportTypeIdentityMetadataName, typeIdentity);
Export composableExport = ExportFactory.Create(
contractName,
metadata,
GetInstance);
this.AddExport(composableExport);
this._imports = new Dictionary <ImportDefinition, object>();
}
public new void AddExport(string contractName, object value)
{
var export = ExportFactory.Create(contractName, () =>
{
this.OnGetExport(contractName); return(value);
});
base.AddExport(export);
}
public void AddExportedValue_ExportAsExportedValueArgument_ShouldBeWrappedInExport()
{
CompositionBatch batch = new CompositionBatch();
var export = ExportFactory.Create("Contract", "Value");
batch.AddExportedValue(export);
Assert.Equal(1, batch.PartsToAdd.Count);
Assert.Same(export, this.GetSingleLazy <Export>(batch.PartsToAdd[0]).Value);
}
public void AddExport_ReturnedComposablePart_IsInAddedPartsCollection()
{
CompositionBatch batch = new CompositionBatch();
var export = ExportFactory.Create("Contract", "Value");
var part = batch.AddExport(export);
Assert.Equal(1, batch.PartsToAdd.Count);
Assert.Equal("Value", this.GetSingleExport(batch.PartsToAdd[0], "Contract").Value);
Assert.Contains(part, batch.PartsToAdd);
}
public void AddExport_ExportWithNullExportedValueAsExportArgument_CanBeExported()
{
CompositionBatch batch = new CompositionBatch();
var export = ExportFactory.Create("Contract", (object)null);
batch.AddExport(export);
Assert.Equal(1, batch.PartsToAdd.Count);
var result = this.GetSingleExport(batch.PartsToAdd[0], "Contract");
Assert.NotNull(result);
Assert.Null(result.Value);
}
public void AddExport_ReturnedComposablePart_NullAsDefinitionArgumentToSetImports_ShouldThrowArgumentNull()
{
CompositionBatch batch = new CompositionBatch();
var export = ExportFactory.Create("Contract", "Value");
var part = batch.AddExport(export);
Assert.Equal(1, batch.PartsToAdd.Count);
Assert.Throws <ArgumentNullException>("definition", () =>
{
part.SetImport((ImportDefinition)null, Enumerable.Empty <Export>());
});
}
public void AddExport_ExportWithEmptyMetadata_IsExportedWithEmptyMetadata()
{
CompositionBatch batch = new CompositionBatch();
var export = ExportFactory.Create("Contract", "Value", new Dictionary <string, object>());
Assert.Equal(0, export.Metadata.Count);
batch.AddExport(export);
Assert.Equal(1, batch.PartsToAdd.Count);
var result = this.GetSingleExport(batch.PartsToAdd[0], "Contract");
Assert.Equal(0, result.Metadata.Count);
}
public void AddExport_ReturnedComposablePart_NullAsDefinitionArgumentToGetExportedValue_ShouldThrowArgumentNull()
{
CompositionBatch batch = new CompositionBatch();
var export = ExportFactory.Create("Contract", "Value");
var part = batch.AddExport(export);
Assert.AreEqual(1, batch.PartsToAdd.Count);
ExceptionAssert.ThrowsArgument <ArgumentNullException>("definition", () =>
{
part.GetExportedValue((ExportDefinition)null);
});
}
public void AddExport_ReturnedComposablePart_ExportsArrayWithNullElementAsExportsArgumentToSetImports_ShouldThrowArgument()
{
CompositionBatch batch = new CompositionBatch();
var export = ExportFactory.Create("Contract", "Value");
var part = batch.AddExport(export);
var definition = ImportDefinitionFactory.Create();
Assert.Equal(1, batch.PartsToAdd.Count);
Assert.Throws <ArgumentException>("exports", () =>
{
part.SetImport(definition, new Export[] { null });
});
}
public void AddExport_ReturnedComposablePart_SetImports_ShouldThrowArgument()
{
CompositionBatch batch = new CompositionBatch();
var export = ExportFactory.Create("Contract", "Value");
var part = batch.AddExport(export);
var definition = ImportDefinitionFactory.Create();
Assert.AreEqual(1, batch.PartsToAdd.Count);
ExceptionAssert.ThrowsArgument <ArgumentException>("definition", () =>
{
part.SetImport(definition, Enumerable.Empty <Export>());
});
}
public void VerifyImport(params int[] expectedValues)
{
object[] untypedExpectedValues = expectedValues.Cast <object>().ToArray();
ExportsAssert.AreEqual(CollectionPlain, untypedExpectedValues);
ExportsAssert.AreEqual(CollectionPlainRawMetadata, untypedExpectedValues);
EnumerableAssert.IsTrueForAll(CollectionPlainRawMetadata, i => true.Equals(i.Metadata["PropertyName"]));
EnumerableAssert.IsEmpty(CollectionPlainEmpty);
EnumerableAssert.IsEmpty(CollectionPlainEmptyRawMetadata);
// Add a new Export to this collection to ensure that it doesn't
// modifiy the other collections because they should each have there
// own collection instance
CollectionPlain.Add(ExportFactory.Create <object>("Value"));
ExportsAssert.AreEqual(CollectionTyped, expectedValues);
ExportsAssert.AreEqual(CollectionTypedRawMetadata, expectedValues);
EnumerableAssert.IsTrueForAll(CollectionTypedRawMetadata, i => true.Equals(i.Metadata["PropertyName"]));
EnumerableAssert.IsEmpty(CollectionTypedEmpty);
ExportsAssert.AreEqual(CollectionTypedMetadata, expectedValues);
#if !SILVERLIGHT // Silverlight doesn't support strongly typed metadata
EnumerableAssert.IsTrueForAll(CollectionTypedMetadata, i => true == i.Metadata.PropertyName);
#endif //!SILVERLIGHT
EnumerableAssert.IsEmpty(CollectionTypedMetadataEmpty);
EnumerableAssert.AreEqual(ReadWriteEnumerable, expectedValues);
EnumerableAssert.IsEmpty(ReadWriteEnumerableEmpty);
ExportsAssert.AreEqual(MetadataUntypedEnumerable, untypedExpectedValues);
ExportsAssert.AreEqual(MetadataUntypedEnumerableRawMetadata, untypedExpectedValues);
EnumerableAssert.IsTrueForAll(MetadataUntypedEnumerableRawMetadata, i => true.Equals(i.Metadata["PropertyName"]));
EnumerableAssert.IsEmpty(MetadataUntypedEnumerableEmpty);
EnumerableAssert.IsEmpty(MetadataUntypedEnumerableEmptyRawMetadata);
ExportsAssert.AreEqual(MetadataTypedEnumerable, expectedValues);
ExportsAssert.AreEqual(MetadataTypedEnumerableRawMetadata, expectedValues);
EnumerableAssert.IsTrueForAll(MetadataTypedEnumerableRawMetadata, i => true.Equals(i.Metadata["PropertyName"]));
EnumerableAssert.IsEmpty(MetadataTypedEnumerableEmpty);
ExportsAssert.AreEqual(MetadataFullyTypedEnumerable, expectedValues);
#if !SILVERLIGHT // Silverlight doesn't support strongly typed metadata
EnumerableAssert.IsTrueForAll(MetadataFullyTypedEnumerable, i => true == i.Metadata.PropertyName);
#endif //!SILVERLIGHT
EnumerableAssert.IsEmpty(MetadataFullyTypedEnumerableEmpty);
}
public void AddExport_ReturnedComposablePart_ContainsExportDefinitionRepresentingExport()
{
var metadata = new Dictionary <string, object>();
metadata["Name"] = "Value";
CompositionBatch batch = new CompositionBatch();
var export = ExportFactory.Create("Contract", "Value", metadata);
var part = batch.AddExport(export);
Assert.Equal(1, batch.PartsToAdd.Count);
var definition = part.ExportDefinitions.Single();
Assert.Equal("Contract", definition.ContractName);
Assert.Equal("Value", part.GetExportedValue(definition));
EnumerableAssert.AreEqual(metadata, definition.Metadata);
}
[ActiveIssue("https://github.com/dotnet/corefx/issues/25498", TestPlatforms.AnyUnix)] // System.Reflection.ReflectionTypeLoadException : Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information.
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>, ITrans_ExportableTest>("Add");
Assert.Equal(3, exports.Count());
foreach (var export in exports)
{
if (export.Metadata.Var1 == "mult")
{
Assert.Equal(2, export.Value(1, 2));
}
else if (export.Metadata.Var1 == "add")
{
Assert.Equal(3, export.Value(1, 2));
}
else if (export.Metadata.Var1 == "sub")
{
Assert.Equal(-1, export.Value(1, 2));
}
else
{
throw new NotImplementedException();
}
}
}
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");
}
}
}
SelfExportWithExportFactoryParameterImport(ExportFactory <IImport <T1, T2> > value)
{
this.Value = value;
}
public void AddExport(string contractName, object value)
{
this.AddExport(ExportFactory.Create(contractName, () => value));
}
public MyEmptyClassWithFactoryConstructor([Import] ExportFactory <IContract> myFactoryProperty)
{
this.MyFactoryProperty = myFactoryProperty;
}
public MyEmptyClassWithFactoryConstructor([Import(RequiredCreationPolicy = CreationPolicy.NewScope)] ExportFactory <IContract> myFactoryProperty)
{
this.MyFactoryProperty = myFactoryProperty;
}