public void ScopingEndToEndWithCompositionService_PartitionedCatalogsShouldSucceed()
{
var c1 = new TypeCatalog(typeof(ClassRoot), typeof(ClassA));
var c2 = new TypeCatalog(typeof(ClassA));
CompositionScopeDefinition sd = c1.AsScope(c2.AsScope());
var container = new CompositionContainer(sd, CompositionOptions.ExportCompositionService);
ClassRoot fromRoot = container.GetExportedValue <ClassRoot>();
ClassA a1 = fromRoot.classA.CreateExport().Value;
ClassA a2 = fromRoot.classA.CreateExport().Value;
fromRoot.localClassA.InstanceValue = 101;
a1.InstanceValue = 202;
a2.InstanceValue = 303;
if (a1.InstanceValue == a2.InstanceValue)
{
throw new Exception("Incorrect sharing, a1 is shared with a2");
}
var xroot = new ImportA();
var x1 = new ImportA();
var x2 = new ImportA();
fromRoot.localClassA.CompositionService.SatisfyImportsOnce(xroot);
a1.CompositionService.SatisfyImportsOnce(x1);
a2.CompositionService.SatisfyImportsOnce(x2);
Assert.Equal(xroot.classA.InstanceValue, fromRoot.localClassA.InstanceValue);
Assert.Equal(x1.classA.InstanceValue, a1.InstanceValue);
Assert.Equal(x2.classA.InstanceValue, a2.InstanceValue);
}
public void DontExportICompositionServiceFromChildImportShouldShouldThrowCompositionException()
{
var rootCatalog = new TypeCatalog(typeof(FromRoot));
var childCatalog = new TypeCatalog(typeof(ClassRequiresICompositionService), typeof(ClassOptionallyImportsICompositionService));
CompositionScopeDefinition scope = rootCatalog.AsScope(childCatalog.AsScope());
var container = new CompositionContainer(scope);
Assert.Throws <ImportCardinalityMismatchException>(() =>
{
FromRoot fromRoot = container.GetExportedValue <FromRoot>();
Assert.Null(fromRoot);
});
}
public void ExportICompositionServiceFromChildImportShouldShouldSucceed()
{
var childCatalog = new TypeCatalog(typeof(ClassRequiresICompositionService), typeof(ClassOptionallyImportsICompositionService));
var rootCatalog = new TypeCatalog(typeof(FromRoot));
CompositionScopeDefinition scope = rootCatalog.AsScope(childCatalog.AsScope());
var container = new CompositionContainer(scope, CompositionOptions.ExportCompositionService);
FromRoot fromRoot = container.GetExportedValue <FromRoot>();
ExportLifetimeContext <ClassRequiresICompositionService> requiredService = fromRoot.Required.CreateExport();
Assert.NotNull(requiredService.Value.CompositionService);
ExportLifetimeContext <ClassOptionallyImportsICompositionService> optionalService = fromRoot.Optional.CreateExport();
Assert.NotNull(optionalService.Value.CompositionService);
}
void Run()
{
// var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
// var container = new CompositionContainer(catalog);
var managerCatalog = new TypeCatalog(typeof(CarManager));
var partCatalog = new TypeCatalog(typeof(CarHost), typeof(CarMercedes), typeof(CarBMW), typeof(CarGarage));
var scope = new CompositionScopeDefinition(
managerCatalog,
new[] { new CompositionScopeDefinition(partCatalog, null) });
var container = new CompositionContainer(scope);
var carManager = container.GetExportedValue <CarManager>();
ExportLifetimeContext <CarHost> carHostContextA = carManager.CreateCarHost();
Console.WriteLine("");
ExportLifetimeContext <CarHost> carHostContextB = carManager.CreateCarHost();
Console.WriteLine("");
foreach (ICarContract carParts in carHostContextA.Value.CarParts)
{
Console.WriteLine(carParts.DoSomething());
}
carHostContextA.Dispose();
Console.WriteLine("");
foreach (ICarContract carParts in carHostContextB.Value.CarParts)
{
Console.WriteLine(carParts.DoSomething());
}
carHostContextB.Dispose();
Console.WriteLine("");
Console.ReadLine();
}
public void ComposeAppInNewScopeChildrenInScope_ShouldSucceed()
{
var childCatalog = new CompositionScopeDefinition(new TypeCatalog(typeof(Foo1), typeof(Child)), new CompositionScopeDefinition[] { });
var rootCatalog = new CompositionScopeDefinition(new TypeCatalog(), new CompositionScopeDefinition[] { childCatalog });
var cs = rootCatalog.CreateCompositionService();
var app = new App();
cs.SatisfyImportsOnce(app);
var e1 = app.FooFactory.CreateExport();
var e2 = app.FooFactory.CreateExport();
var e3 = app.FooFactory.CreateExport();
e1.Value.FooChild.FooValue = 10;
e2.Value.FooChild.FooValue = 20;
e3.Value.FooChild.FooValue = 30;
Assert.Equal <int>(10, e1.Value.FooChild.FooValue);
Assert.Equal <int>(20, e2.Value.FooChild.FooValue);
Assert.Equal <int>(30, e3.Value.FooChild.FooValue);
}
internal void Register(IList <Tuple <string, string> > pathsToScan)
{
RegisteringEventArgs rea = new RegisteringEventArgs();
OnRegistering(rea);
AggregateCatalog aggc = new AggregateCatalog();
List <DirectoryCatalog> catalogs = new List <DirectoryCatalog>();
List <ComposablePartDefinition> parts = new List <ComposablePartDefinition>();
foreach (var pathScan in pathsToScan)
{
string folder = String.IsNullOrEmpty(pathScan.Item1) ? System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) : pathScan.Item1; //Default if empty
string path = System.IO.Path.Combine(folder, pathScan.Item2); //Full path
if (!catalogs.Exists(x => System.IO.Path.Combine(x.FullPath.ToUpperInvariant(), x.SearchPattern).ToUpperInvariant() == path.ToUpperInvariant()))
{ //Check if same path is already loaded
DirectoryCatalog dc = new DirectoryCatalog(folder, pathScan.Item2);
if (dc.Parts.All(x => parts.Exists(y => y.ToString() == x.ToString())))
{//Check all parts, same assembly with different name or same assembly in two differents locations
dc.Dispose();
}
else
{
parts.AddRange(dc.Parts);
if (dc.LoadedFiles.Count() > 0)
{//Only add if assemblies loaded
catalogs.Add(dc);
for (int i = 0; i < catalogs.IndexOf(dc); i++)
{
if (catalogs.ElementAt(i).LoadedFiles.Intersect(dc.LoadedFiles).Count() > 0)
{ //There are similar files
if (catalogs.ElementAt(i).LoadedFiles.Count() > dc.LoadedFiles.Count())
{ //One of them could have more files than another, take the higher
catalogs.Remove(dc);
}
else
{
catalogs.Remove(catalogs.ElementAt(i));
}
}
}
}
}
}
}
catalogs.ForEach(x => aggc.Catalogs.Add(x));
aggc.Catalogs.Add(rea.TypeCatalog);
ContainerSimple = new CompositionContainer(aggc, CompositionOptions.DisableSilentRejection | CompositionOptions.IsThreadSafe);
var scopeDefDependent = new CompositionScopeDefinition(ContainerSimple.Catalog, null);
var appCatalog = new TypeCatalog(typeof(ApplicationFactory <>));
var scopeDefRoot = new CompositionScopeDefinition(appCatalog, new[] { scopeDefDependent });
ContainerFactory = new CompositionContainer(scopeDefRoot, CompositionOptions.IsThreadSafe);
OnRegistered(new RegisteredEventArgs(this.ContainerSimple, this.ContainerFactory));
}