/// <summary>
/// Initializes a new instance of the <see cref="GenericCatalog"/> class.
/// </summary>
/// <param name="catalog"><see cref="ComposablePartCatalog"/> from which <see cref="IGenericContractRegistry"/> instances will be retrieved.</param>
/// <param name="registries">Additional registries.</param>
public GenericCatalog(ComposablePartCatalog catalog, params IGenericContractRegistry[] registries)
{
var cfg = new InterceptionConfiguration()
.AddHandler(new GenericExportHandler(registries));
this.interceptingCatalog = new InterceptingCatalog(catalog, cfg);
}
static void Main(string[] args)
{
InterceptionConfiguration cfg = new InterceptionConfiguration()
.AddInterceptor(new DynamicProxyInterceptor(new LoggingInterceptor()));
//GenericTypeCatalog typeCatalog = new GenericTypeCatalog(typeof(GenericClass<int>), typeof(IGenericInterface<>));
//AssemblyCatalog assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
//AggregateCatalog aggregateCatalog = new AggregateCatalog(assemblyCatalog, typeCatalog);
//GenericCatalog genericCatalog = new GenericCatalog(aggregateCatalog);
//InterceptingCatalog interceptingCatalog = new InterceptingCatalog(genericCatalog, cfg);
//CompositionContainer container = new CompositionContainer(interceptingCatalog);
// GenericContractTypeMapping mapping = new GenericContractTypeMapping(typeof(IGenericInterface<>), typeof(GenericClass<>));
TypeCatalog typeCatalog = new TypeCatalog(typeof(SampleClass), typeof(OrderProcessor), typeof(CtorOrderProcessor));
AssemblyCatalog assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
GenericCatalog genericCatalog = new GenericCatalog(new TestGenericContractRegistry());
AggregateCatalog aggregateCatalog = new AggregateCatalog(typeCatalog, genericCatalog);
//CompositionContainer container = new CompositionContainer(aggregateCatalog);
CompositionContainer container = new CompositionContainer(aggregateCatalog);
var orderProcessor = container.GetExportedValue <OrderProcessor>();
var generic = container.GetExportedValue <IGenericInterface <string> >();
CatalogExportProvider provider = new CatalogExportProvider(aggregateCatalog);
provider.SourceProvider = provider;
var instance = provider.GetExportedValue <ISampleInterface>();//container.GetExportedValue<ISampleInterface>();
instance.Method1("test", 5);
var genericInstance = provider.GetExportedValue <OrderProcessor>();//container.GetExportedValue<IGenericInterface<int>>();
//var orderProcessor = provider.GetExportedValue<CtorOrderProcessor>();
}
public void When_removing_a_part_from_the_intercepted_catalog_intercepting_catalog_is_recomposed_and_removes_that_part()
{
var innerCatalog1 = new TypeCatalog(typeof(RecomposablePart1), typeof(RecomposablePartImporter));
var innerCatalog2 = new TypeCatalog(typeof(RecomposablePart2));
var cfg = new InterceptionConfiguration().AddInterceptor(new RecomposablePartInterceptor());
var aggregateCatalog = new AggregateCatalog(innerCatalog1, innerCatalog2);
var catalog = new InterceptingCatalog(aggregateCatalog, cfg);
container = new CompositionContainer(catalog);
var importer = container.GetExportedValue <RecomposablePartImporter>();
Assert.That(importer, Is.Not.Null);
Assert.That(importer.Parts, Is.Not.Null);
Assert.That(importer.Parts.Length, Is.EqualTo(2));
Assert.That(importer.Parts[0].Count, Is.EqualTo(1));
Assert.That(importer.Parts[1].Count, Is.EqualTo(1));
Assert.That(catalog.Parts.Count(), Is.EqualTo(3));
// Recompose
aggregateCatalog.Catalogs.Remove(innerCatalog2);
Assert.That(importer, Is.Not.Null);
Assert.That(importer.Parts, Is.Not.Null);
Assert.That(importer.Parts.Length, Is.EqualTo(1));
Assert.That(importer.Parts[0].Count, Is.EqualTo(1));
Assert.That(catalog.Parts.Count(), Is.EqualTo(2));
}
public void When_removing_existing_part_from_the_part_handler_intercepting_catalog_is_recomposed_and_removes_that_part()
{
var partHandler = new RecomposablePartHandler();
var part2Catalog = new TypeCatalog(typeof(RecomposablePart2));
var innerCatalog = new TypeCatalog(typeof(RecomposablePartImporter), typeof(RecomposablePart1));
var aggregateCatalog = new AggregateCatalog(innerCatalog, part2Catalog);
var cfg = new InterceptionConfiguration()
.AddInterceptor(new RecomposablePartInterceptor())
.AddHandler(partHandler);
var catalog = new InterceptingCatalog(aggregateCatalog, cfg);
container = new CompositionContainer(catalog);
var importer = container.GetExportedValue <RecomposablePartImporter>();
Assert.That(importer, Is.Not.Null);
Assert.That(importer.Parts, Is.Not.Null);
Assert.That(importer.Parts.Length, Is.EqualTo(2));
Assert.That(importer.Parts[0].Count, Is.EqualTo(1));
Assert.That(importer.Parts[1].Count, Is.EqualTo(1));
Assert.That(catalog.Parts.Count(), Is.EqualTo(3));
Assert.That(catalog.Parts.OfType <InterceptingComposablePartDefinition>().Count(), Is.EqualTo(3));
// Recompose
partHandler.RemoveParts(part2Catalog);
Assert.That(importer, Is.Not.Null);
Assert.That(importer.Parts, Is.Not.Null);
Assert.That(importer.Parts.Length, Is.EqualTo(1));
Assert.That(importer.Parts[0].Count, Is.EqualTo(1));
Assert.That(importer.Parts[0].GetType(), Is.EqualTo(typeof(RecomposablePart1)));
Assert.That(catalog.Parts.Count(), Is.EqualTo(2));
Assert.That(catalog.Parts.OfType <InterceptingComposablePartDefinition>().Count(), Is.EqualTo(2));
}
public void Adding_interception_criteria_is_reflected_in_the_InterceptionCriteria_collection()
{
var cfg = new InterceptionConfiguration()
.AddInterceptionCriteria(new PredicateInterceptionCriteria(new FakeInterceptor(), part => true));
Assert.That(cfg.InterceptionCriteria.Count(), Is.EqualTo(1));
Assert.That(cfg.InterceptionCriteria.OfType <PredicateInterceptionCriteria>().Any());
}
public MefBuilder(IContainerBuilder builder, ComposablePartCatalog catalog)
{
var cfg = new InterceptionConfiguration();
builder.ObjectSource.CreationInterceptors.ForEach(i => cfg.AddInterceptor(new CreationInterceptor(i)));
cfg.AddInterceptor(new ProxyObjectInterceptor(builder.ObjectSource));
var interceptingCatalog = new InterceptingCatalog(catalog, cfg);
Container = new CompositionContainer(interceptingCatalog);
}
public void Adding_interceptors_is_reflected_in_the_Interceptors_collection()
{
var cfg = new InterceptionConfiguration()
.AddInterceptor(new CompositeValueInterceptor())
.AddInterceptor(new FakeInterceptor());
Assert.That(cfg.Interceptors.Count(), Is.EqualTo(2));
Assert.That(cfg.Interceptors.OfType <CompositeValueInterceptor>().Any());
Assert.That(cfg.Interceptors.OfType <FakeInterceptor>().Any());
}
public void When_querying_for_a_part_not_being_intercepted_it_should_return_original_part_definition()
{
var innerCatalog = new TypeCatalog(typeof(Logger));
var cfg = new InterceptionConfiguration();
var catalog = new InterceptingCatalog(innerCatalog, cfg);
var partDefinition = catalog.Parts.First();
partDefinition.ShouldNotBeOfType <InterceptingComposablePartDefinition>();
}
public void Adding_part_handlers_is_reflected_in_the_PartHandlers_collection()
{
var cfg = new InterceptionConfiguration()
.AddHandler(new FakePartHandler1())
.AddHandler(new FakePartHandler1());
Assert.That(cfg.PartHandlers.Count(), Is.EqualTo(2));
Assert.That(cfg.PartHandlers.OfType <FakePartHandler1>().Any());
Assert.That(cfg.PartHandlers.OfType <FakePartHandler1>().Any());
}
public void When_querying_for_a_part_it_should_return_an_intercepting_part_definition()
{
var innerCatalog = new TypeCatalog(typeof(Logger));
var mockInterceptor = new Mock <IExportedValueInterceptor>();
var cfg = new InterceptionConfiguration().AddInterceptor(mockInterceptor.Object);
var catalog = new InterceptingCatalog(innerCatalog, cfg);
var partDefinition = catalog.Parts.First();
partDefinition.ShouldBeOfType <InterceptingComposablePartDefinition>();
}
public void TestSetUp()
{
var typeCatalog = new TypeCatalog(typeof(CtorOrderProcessor), typeof(OrderProcessor), typeof(TestGenericContractRegistry));
var cfg = new InterceptionConfiguration().AddHandler(new GenericExportHandler());
var catalog = new InterceptingCatalog(typeCatalog, cfg);
var provider = new CatalogExportProvider(catalog);
provider.SourceProvider = provider;
ExportProvider = provider;
}
/// <summary>
/// Initializes a new instance of the <see cref="ConventionCatalog"/> class, using the provided array part registries.
/// </summary>
/// <param name="registries">An array of <see cref="IPartRegistry{T}"/> instance.</param>
public ConventionCatalog(params IPartRegistry <IContractService>[] registries)
{
if (registries == null)
{
throw new ArgumentNullException("registries", "The registries parameter cannot be null.");
}
var cfg = new InterceptionConfiguration()
.AddHandler(new ConventionPartHandler(registries));
this.interceptingCatalog = new InterceptingCatalog(new EmptyCatalog(), cfg);
}
public void TestSetUp()
{
var innerCatalog = new TypeCatalog(typeof(Part1), typeof(Part2), typeof(Part3));
var cfg = new InterceptionConfiguration()
.AddInterceptor(new GeneralInterceptor())
.AddInterceptionCriteria(
new PredicateInterceptionCriteria(
new PartInterceptor(), d => d.Metadata.ContainsKey("metadata1")));
var catalog = new InterceptingCatalog(innerCatalog, cfg);
container = new CompositionContainer(catalog);
}
public void TestSetUp()
{
var innerCatalog = new TypeCatalog(typeof(Customer));
var interceptor = new InterfaceInterceptor();
var valueInterceptor = new DynamicProxyInterceptor(interceptor);
var cfg = new InterceptionConfiguration()
.AddInterceptor(valueInterceptor);
var catalog = new InterceptingCatalog(innerCatalog, cfg);
container = new CompositionContainer(catalog);
}
public void Catalog_should_call_Initialize_on_a_given_part_handlers()
{
var innerCatalog = new TypeCatalog();
var partHandlerMock = new Mock <IPartHandler>(MockBehavior.Strict);
partHandlerMock.Setup(p => p.Initialize(innerCatalog)).Verifiable();
var cfg = new InterceptionConfiguration()
.AddHandler(partHandlerMock.Object);
var catalog = new InterceptingCatalog(innerCatalog, cfg);
Assert.That(catalog, Is.Not.Null);
partHandlerMock.Verify();
}
public Request(ComposablePartCatalog parentCatalog, CompositionContainer parentContainer)
{
Console.WriteLine("/* Request */");
// Create interception configuration with non-shared parts filter
var cfg = new InterceptionConfiguration()
.AddHandler(new PartCreationPolicyFilter(CreationPolicy.NonShared));
// Create the InterceptingCatalog with above configuration
var interceptingCatalog = new InterceptingCatalog(parentCatalog, cfg);
// Create the child container
this.requestContainer = new CompositionContainer(interceptingCatalog, parentContainer);
}
public void Catalog_should_filter_out_parts()
{
var innerCatalog = new TypeCatalog(typeof(Part0), typeof(Part1), typeof(Part2), typeof(Part3));
var cfg = new InterceptionConfiguration()
.AddHandler(new PartFilter());
var catalog = new InterceptingCatalog(innerCatalog, cfg);
container = new CompositionContainer(catalog);
var parts = container.GetExportedValues <IPart>();
Assert.That(parts.Count(), Is.EqualTo(1));
Assert.That(parts.First().GetType(), Is.EqualTo(typeof(Part0)));
}
static void Main(string[] args)
{
AssemblyCatalog assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
InterceptionConfiguration cfg = new InterceptionConfiguration();
cfg.AddInterceptor(new MefContrib.Hosting.Interception.Castle.DynamicProxyInterceptor(new CastleLoggingInterceptor()));
InterceptingCatalog interceptingCatalog = new InterceptingCatalog(assemblyCatalog, cfg);
CompositionContainer container = new CompositionContainer(interceptingCatalog);
ISampleInterface intercepted = container.GetExportedValue <ISampleInterface>();
intercepted.Say("Hello World!");
intercepted.Say(new SayArgs("Hello World with args!"));
}
private ComposablePartCatalog GetInterceptionCatalog()
{
_applicationCatalog = new ApplicationCatalog();
_adapterdirectoryCatalog = new DirectoryCatalog(AdaptersDirectory);
_pluginsdirectoryCatalog = new DirectoryCatalog(PluginsDirectory);
var catalog = new AggregateCatalog(_applicationCatalog, _adapterdirectoryCatalog, _pluginsdirectoryCatalog);
var cfg = new InterceptionConfiguration().AddInterceptionCriteria(
new PredicateInterceptionCriteria(
new CopyConfigInterceptor(_robot.Settings),
def => def.ExportDefinitions.First().ContractName.Contains("IAdapter") ||
def.ExportDefinitions.First().ContractName.Contains("IRobotPlugin")));
return(new InterceptingCatalog(catalog, cfg));
}
public void Run()
{
Console.WriteLine("\n*** Interception Demo ***");
// Create source catalog
var catalog = new TypeCatalog(typeof(Bar), typeof(Foo));
// Create interception configuration
var cfg = new InterceptionConfiguration()
// Add catalog wide startable interceptor
.AddInterceptor(new StartableStrategy())
/*
* .AddInterceptionCriteria(
* new LogInterceptionCriteria(
* new DynamicProxyInterceptor(
* new LoggingInterceptor())))
*/
// Add Castle DynamicProxy based logging interceptor for parts
// which want to be logged, does exactly the same as the above code
.AddInterceptionCriteria(
new PredicateInterceptionCriteria(
// Apply the interceptor only to parts which contain
// Log export metadata which equals to true
new DynamicProxyInterceptor(new LoggingInterceptor()), def =>
def.ExportDefinitions.First().Metadata.ContainsKey("Log") &&
def.ExportDefinitions.First().Metadata["Log"].Equals(true)));
// Create the InterceptingCatalog with above configuration
var interceptingCatalog = new InterceptingCatalog(catalog, cfg);
// Create the container
var container = new CompositionContainer(interceptingCatalog);
// Bar part will be intercepted only by the startable strategy
var barPart = container.GetExportedValue <IBar>();
barPart.Foo();
// Foo part will be intercepted by both startable and logging strategies
var fooPart = container.GetExportedValue <IFoo>();
fooPart.Bar();
}
/// <summary>
/// Initializes a new instance of the <see cref="FilteringCatalog"/> class.
/// </summary>
/// <param name="inner">A <see cref="ComposablePartCatalog"/> whose parts
/// are to be filtered based on a given criteria.</param>
/// <param name="filter">A filter query.</param>
public FilteringCatalog(ComposablePartCatalog inner, Func <ComposablePartDefinition, bool> filter)
{
if (inner == null)
{
throw new ArgumentNullException("inner");
}
if (filter == null)
{
throw new ArgumentNullException("filter");
}
var cfg = new InterceptionConfiguration()
.AddHandler(new FilteringPartHandler(filter));
this.interceptingCatalog = new InterceptingCatalog(inner, cfg);
}
private static CompositionContainer CreateContainer1()
{
// Create source catalog, note we are passing the registry part.
// During the runtime, GenericExportHandler will query this catalog for
// all types implementing IGenericContractRegistry
var typeCatalog = new TypeCatalog(typeof(Trampoline), typeof(MyGenericContractRegistry));
// Create the interception configuration and add support for open generics
var cfg = new InterceptionConfiguration()
.AddHandler(new GenericExportHandler());
// Create the InterceptingCatalog and pass the configuration
var interceptingCatalog = new InterceptingCatalog(typeCatalog, cfg);
// Create the container
return(new CompositionContainer(interceptingCatalog));
}
public static IInterceptionConfiguration Intercept(this FluentAspectOptions options,
Func <IInvocation, bool> predict)
{
if (null == predict)
{
throw new ArgumentNullException(nameof(predict));
}
if (options.InterceptionConfigurations.TryGetValue
(predict, out var interceptionConfiguration))
{
return(interceptionConfiguration);
}
interceptionConfiguration = new InterceptionConfiguration();
options.InterceptionConfigurations[predict] = interceptionConfiguration;
return(interceptionConfiguration);
}
public void Disposing_catalog_should_dispose_parts_implementing_dispose_pattern()
{
var innerCatalog = new TypeCatalog(typeof(DisposablePart));
var cfg = new InterceptionConfiguration()
.AddInterceptor(new FakeInterceptor());
var catalog = new InterceptingCatalog(innerCatalog, cfg);
var partDefinition = catalog.Parts.First();
container = new CompositionContainer(catalog);
partDefinition.ShouldBeOfType <InterceptingComposablePartDefinition>();
var part = container.GetExportedValueOrDefault <DisposablePart>();
Assert.That(part.IsDisposed, Is.False);
container.Dispose();
Assert.That(part.IsDisposed, Is.True);
}
public void When_adding_new_part_to_the_intercepted_catalog_intercepting_catalog_raises_recomposition_events()
{
var innerCatalog = new TypeCatalog(typeof(RecomposablePart1));
var cfg = new InterceptionConfiguration().AddInterceptor(new RecomposablePartInterceptor());
var aggregateCatalog = new AggregateCatalog(innerCatalog);
var catalog = new InterceptingCatalog(aggregateCatalog, cfg);
container = new CompositionContainer(catalog);
uint changingEventInvokeCount = 0;
uint changedEventInvokeCount = 0;
catalog.Changing += (s, e) => changingEventInvokeCount++;
catalog.Changed += (s, e) => changedEventInvokeCount++;
// Recompose
aggregateCatalog.Catalogs.Add(new TypeCatalog(typeof(RecomposablePart2)));
Assert.That(changingEventInvokeCount, Is.EqualTo(1));
Assert.That(changedEventInvokeCount, Is.EqualTo(1));
}
