public static void CompleteInitialization()
{
Assembly[] partsAssemblies;
lock (_initLock)
{
if (_isInitialized)
return;
_isInitialized = true;
partsAssemblies = _partAssemblies.Union(FindWebApplicationAssemblies()).ToArray();
}
var conventions = new ConventionBuilder()
.WithMvcConventions()
.WithEagerConstructionSupport();
conventions.ForTypesUnderNamespace("Parts").Export().ExportInterfaces();
var container = new ContainerConfiguration()
.WithDefaultConventions(conventions)
.WithAssemblies(partsAssemblies)
.WithApplicationSettings()
.CreateContainer();
MvcCompositionProvider.Initialize(container);
CompositionFilterProvider.Install(FilterProviders.Providers);
ImportCapableFilterAttributeFilterProvider.Install(FilterProviders.Providers);
container.ConstructEagerParts();
}
public static void RegistrationByConvention(this Container container,
BehaviorConfiguration configuration,
Action<IConventionBuilderSyntax<Lifestyle, Container>> convention)
{
if (configuration == null)
{
configuration = BehaviorConfiguration.Default;
}
var logger = new DiagnosticLogger(configuration);
var serviceMappingTracker = new ServiceMappingTracker(logger);
var implementationFilter = new ImplementationFilter();
var adapter = new SimpleInjectorContainerAdapter(container, serviceMappingTracker, implementationFilter);
var configServiceFilter = ((IBehaviorConfiguration)configuration).GetServiceFilter();
var asmSelector = new AssemblySelector();
var serviceExtractor = new ServiceExtractor();
var containerDecorator = new ContainerLogger<Lifestyle>(adapter, logger);
var serviceFilterAggregator = new ServiceFilterAggregator(new IServiceFilter[] { configServiceFilter, implementationFilter, serviceExtractor, serviceMappingTracker });
using (var builder = new ConventionBuilder<Lifestyle>(containerDecorator,
asmSelector,
serviceFilterAggregator,
serviceExtractor))
{
var importer = new ConventionBuilderSyntaxDecorator<Lifestyle, Container>(builder, container, implementationFilter, asmSelector);
convention(importer);
}
}
// *** Protected Methods ***
protected ContainerConfiguration GetOkraContainerConfiguration()
{
// Create a basic container configuration with,
// - The Okra assembly (via the INavigationManager interface)
// - The Okra.MEF assembly (via the OkraBootstrapper class)
ConventionBuilder okraConventionBuilder = new ConventionBuilder();
okraConventionBuilder.ForType<NavigationManager>().Export<INavigationManager>()
.Shared()
.SelectConstructor(ctors => ctors.First(), (info, builder) =>
{
if (info.ParameterType == typeof(INavigationTarget))
builder.AllowDefault();
});
okraConventionBuilder.ForType<SettingsPaneManager>().Export<ISettingsPaneManager>().Shared();
okraConventionBuilder.ForType<ActivationManager>().Export<IActivationManager>().Shared();
okraConventionBuilder.ForType<SearchManager>().Export<ISearchManager>().Shared();
okraConventionBuilder.ForType<ShareSourceManager>().Export<IShareSourceManager>().Shared();
okraConventionBuilder.ForType<ShareTargetManager>().Export<IShareTargetManager>().Shared();
okraConventionBuilder.ForType<LifetimeManager>().Export<ILifetimeManager>().Shared();
okraConventionBuilder.ForType<StorageManager>().Export<IStorageManager>().Shared();
okraConventionBuilder.ForType<LaunchActivationHandler>().Export<ILaunchActivationHandler>().Shared();
return new ContainerConfiguration()
.WithAssembly(typeof(INavigationManager).GetTypeInfo().Assembly, okraConventionBuilder)
.WithAssembly(typeof(OkraBootstrapper).GetTypeInfo().Assembly);
}
public void UsingNLog()
{
var writer = GetTrace();
LoggingConfiguration config = new LoggingConfiguration();
TraceTarget target = new TraceTarget();
target.Layout = "NLOG [${level:uppercase=true}] ${message}";
config.AddTarget("trace", target);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, target));
LogManager.Configuration = config;
ConventionBuilder.Logger = t => LogManager.GetLogger(t);
var builder = new ConventionBuilder();
builder.ScanThisAssembly().For<HandlerConventions>();
var convention = builder.Build();
Approvals.VerifyAll(writer
.ToString()
.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries)
.OrderBy(s => s), "");
}
// *** Protected Methods ***
protected virtual ContainerConfiguration GetContainerConfiguration()
{
// Create a basic container configuration with,
// - The application's main assembly (i.e. that defines the current Application subclass)
// - The Cocoon assembly (via the INavigationManager interface)
// - The Cocoon.MEF assembly (via the CocoonBootstrapper class)
ConventionBuilder cocoonConventionBuilder = new ConventionBuilder();
cocoonConventionBuilder.ForType<NavigationManager>().Export<INavigationManager>()
.Shared()
.SelectConstructor(ctors => ctors.First(), (info, builder) =>
{
if (info.ParameterType == typeof(INavigationTarget))
builder.AllowDefault();
});
cocoonConventionBuilder.ForType<ActivationManager>().Export<IActivationManager>().Shared();
cocoonConventionBuilder.ForType<LifetimeManager>().Export<ILifetimeManager>().Shared();
cocoonConventionBuilder.ForType<StorageManager>().Export<IStorageManager>().Shared();
return new ContainerConfiguration()
.WithAssembly(Application.Current.GetType().GetTypeInfo().Assembly)
.WithAssembly(typeof(INavigationManager).GetTypeInfo().Assembly, cocoonConventionBuilder)
.WithAssembly(typeof(CocoonBootstrapper).GetTypeInfo().Assembly);
}
static partial void AddWinRTSpecificConventions( ConventionBuilder builder )
{
var assembly = new PublicKeyTokenSpecification( typeof( Host ) );
var settingsFlyout = new SettingsFlyoutSpecification();
builder.ForTypesMatching( settingsFlyout.IsSatisfiedBy ).Export().Export<SettingsFlyout>().ExportInterfaces( assembly.IsSatisfiedBy ).ImportProperties( p => p != null && p.Name == "Model" );
}
public void StandardExportInterfacesShouldWork()
{
// Export all interfaces except IDisposable, Export contracts on types without interfaces. except for disposable types
var builder = new ConventionBuilder();
builder.ForTypesMatching((t) => true).ExportInterfaces();
builder.ForTypesMatching((t) => t.GetTypeInfo().ImplementedInterfaces.Where((iface) => iface != typeof(System.IDisposable)).Count() == 0).Export();
var container = new ContainerConfiguration()
.WithPart<Standard>(builder)
.WithPart<Dippy>(builder)
.WithPart<Derived>(builder)
.WithPart<BareClass>(builder)
.CreateContainer();
var importer = new Importer();
container.SatisfyImports(importer);
Assert.NotNull(importer.First);
Assert.True(importer.First.Count() == 3);
Assert.NotNull(importer.Second);
Assert.True(importer.Second.Count() == 3);
Assert.NotNull(importer.Third);
Assert.True(importer.Third.Count() == 3);
Assert.NotNull(importer.Fourth);
Assert.True(importer.Fourth.Count() == 3);
Assert.NotNull(importer.Fifth);
Assert.True(importer.Fifth.Count() == 3);
Assert.Null(importer.Base);
Assert.Null(importer.Derived);
Assert.Null(importer.Dippy);
Assert.Null(importer.Standard);
Assert.Null(importer.Disposable);
Assert.NotNull(importer.BareClass);
}
public static void ConfigureContainer()
{
var containerConventions = new ConventionBuilder();
containerConventions.ForType<DbProductRepository>()
.ExportInterfaces()
.SelectConstructorWithMostParameters()
.InstancePerHttpRequest();
containerConventions.ForType<DbLogger>()
.ExportInterfaces()
.SelectConstructorWithMostParameters()
.InstancePerHttpRequest();
containerConventions.ForType<ProductDbContext>()
.Export()
.InstancePerHttpRequest();
containerConventions.ForTypesDerivedFrom<Controller>()
.Export<IController>()
.Export()
.SelectConstructorWithMostParameters();
var containerConfig = new ContainerConfiguration();
containerConfig.WithAssembly(Assembly.GetExecutingAssembly(), containerConventions);
containerConfig.CreateContainer().UseWithMvc();
}
public void MapType_OverridingSelectionOfConventionSelectedConstructor()
{
var builder = new ConventionBuilder();
builder.
ForTypesDerivedFrom<IFoo>().
Export<IFoo>();
builder.ForType<FooImplWithConstructors>()
.SelectConstructor(cis => cis.ElementAtOrDefault(1));
var fooImplWithConstructors = typeof(FooImplWithConstructors).GetTypeInfo();
var constructor1 = fooImplWithConstructors.DeclaredConstructors.Where(c => c.GetParameters().Length == 0).Single();
var constructor2 = fooImplWithConstructors.DeclaredConstructors.Where(c => c.GetParameters().Length == 1).Single();
var constructor3 = fooImplWithConstructors.DeclaredConstructors.Where(c => c.GetParameters().Length == 2).Single();
// necessary as BuildConventionConstructorAttributes is only called for type level query for attributes
Assert.Equal(0, builder.GetCustomAttributes(typeof(FooImplWithConstructors), constructor1).Count());
Assert.Equal(0, builder.GetCustomAttributes(typeof(FooImplWithConstructors), constructor3).Count());
var ci = constructor2;
var attrs = builder.GetCustomAttributes(typeof(FooImplWithConstructors), ci);
Assert.Equal(1, attrs.Count());
Assert.Equal(typeof(ImportingConstructorAttribute), attrs.FirstOrDefault().GetType());
}
protected static CompositionContext CreateContainer(ConventionBuilder rb, params Type[] types)
{
return new ContainerConfiguration()
.WithParts(types)
.WithDefaultConventions(rb)
.CreateContainer();
}
public void CanSpecifyExportsWithConventionBuilder()
{
var rb = new ConventionBuilder();
rb.ForType<BarePart>().Export();
var cc = CreateContainer(rb, typeof(BarePart));
var x = cc.GetExport<BarePart>();
Assert.NotNull(x);
}
static partial void AddUISpecificConventions( ConventionBuilder builder )
{
var viewModel = new ViewModelSpecification();
builder.ForTypesDerivedFrom<IShellView>().Export().Export<IShellView>().Shared();
builder.ForTypesMatching( viewModel.IsSatisfiedBy ).Export();
builder.ForType<EventBroker>().Export<IEventBroker>().Shared();
}
public void AsContractName_AndContractType_SetsContractNameAndType()
{
var builder = new ConventionBuilder();
builder.ForType<FooImpl>().ImportProperty((p) => p.IFooProperty, (c) => c.AsContractName("hey"));
ImportAttribute importAtt = GetImportAttribute(builder);
Assert.Equal("hey", importAtt.ContractName);
}
public void AsContractName_AndContractType_ComputeContractNameFromType()
{
var builder = new ConventionBuilder();
builder.ForType<FooImpl>().ImportProperty((p) => p.IFooProperty, c => c.AsContractName(t => "Contract:" + t.FullName));
ImportAttribute importAtt = GetImportAttribute(builder);
Assert.Equal("Contract:" + typeof(IFoo).FullName, importAtt.ContractName);
}
public void AsContractName_AndContractType_SetsContractNameAndType()
{
var builder = new ConventionBuilder();
builder.ForTypesDerivedFrom<IFoo>().Export((e) => e.AsContractName("hey").AsContractType(typeof(IFoo)));
ExportAttribute exportAtt = GetExportAttribute(builder);
Assert.Equal("hey", exportAtt.ContractName);
Assert.Equal(typeof(IFoo), exportAtt.ContractType);
}
public void ImportPropertyTargetingBaseClass_ShouldGenerateImportManyForPropertySelected()
{
var builder = new ConventionBuilder();
builder.ForType<DerClass>().ImportProperty(p => p.P3); // P3 is IEnumerable<int>
var importManyAttribute = GetAttributeFromMember(builder, typeof(DerClass), "P3") as ImportManyAttribute;
Assert.NotNull(importManyAttribute);
Assert.Null(importManyAttribute.ContractName);
}
public void AddImportConstraint_AddsImportConstraintMetadataAttribute()
{
var builder = new ConventionBuilder();
builder.ForType<FooImpl>().ImportProperty((p) => p.IFooProperty, (c) => c.AddMetadataConstraint("name", "val"));
ImportMetadataConstraintAttribute importMetadataConstraint = GetImportMetadataConstraintAttribute(builder);
Assert.Equal("name", importMetadataConstraint.Name);
Assert.Equal("val", importMetadataConstraint.Value);
}
public void ExportInterfaceWithTypeOf2()
{
var builder = new ConventionBuilder();
builder.ForType(typeof(CFoo)).Export((c) => c.AsContractType(typeof(IFoo)));
var exports = builder.GetDeclaredAttributes(typeof(CFoo), typeof(CFoo).GetTypeInfo()).Where<Attribute>(e => e is ExportAttribute).Cast<ExportAttribute>();
Assert.Equal(1, exports.Count());
Assert.Equal(exports.First().ContractType, typeof(IFoo));
}
public void AsContractTypeOfT_SetsContractType()
{
var builder = new ConventionBuilder();
builder.ForTypesDerivedFrom<IFoo>().Export((e) => e.AsContractType<IFoo>());
ExportAttribute exportAtt = GetExportAttribute(builder);
Assert.Equal(typeof(IFoo), exportAtt.ContractType);
Assert.Null(exportAtt.ContractName);
}
static partial void AddPlatformSpecificConventions( ConventionBuilder builder )
{
var assembly = new PublicKeyTokenSpecification( typeof( Host ) );
var window = new AssignableSpecification<Window>().And( new AssignableSpecification<IShellView>().Not() );
var userControl = new AssignableSpecification<UserControl>().And( new AssignableSpecification<IShellView>().Not() );
builder.ForTypesMatching( window.IsSatisfiedBy ).Export().ExportInterfaces( assembly.IsSatisfiedBy ).ImportProperties( p => p != null && p.Name == "Model" );
builder.ForTypesMatching( userControl.IsSatisfiedBy ).Export().ExportInterfaces( assembly.IsSatisfiedBy ).ImportProperties( p => p != null && p.Name == "Model" );
}
public void AllowDefault_SetsAllowDefaultProperty()
{
var builder = new ConventionBuilder();
builder.ForType<FooImpl>().ImportProperty((p) => p.IFooProperty, (c) => c.AllowDefault());
ImportAttribute importAtt = GetImportAttribute(builder);
Assert.True(importAtt.AllowDefault);
Assert.Null(importAtt.ContractName);
}
public void ExportInterfaceWithTypeOf1()
{
var builder = new ConventionBuilder();
builder.ForType<FooImpl>().Export<IFoo>();
var exports = builder.GetCustomAttributes(typeof(FooImpl), typeof(FooImpl).GetTypeInfo()).Where<Attribute>(e => e is ExportAttribute).Cast<ExportAttribute>();
Assert.Equal(1, exports.Count());
Assert.Equal(exports.First().ContractType, typeof(IFoo));
}
public void WhenExportingInterfaces_NoPredicate_OnlyContractInterfacesAreExported()
{
var builder = new ConventionBuilder();
builder.ForType<ClassWithLifetimeConcerns>().ExportInterfaces();
var attributes = GetExportAttributes(builder, typeof(ClassWithLifetimeConcerns));
var exportedContracts = attributes.Select(e => e.ContractType).ToArray();
AssertX.Equivalent(s_contractInterfaces, exportedContracts);
}
public void AsMany_And_ContractName_ChangesGeneratedAttributeToImportMany()
{
var builder = new ConventionBuilder();
builder.ForType<FooImpl>().ImportProperty((p) => p.IFooProperty, (c) => c.AsContractName("hey").AsMany());
ImportManyAttribute importAtt = GetImportManyAttribute(builder);
Assert.NotNull(importAtt);
Assert.Equal("hey", importAtt.ContractName);
}
public void ImportPropertyTargetingDerivedClass_ShouldGenerateImportForPropertySelected()
{
var builder = new ConventionBuilder();
builder.ForType<DerClass>().ImportProperty(p => p.P4); // P4 is string
var importAttribute = GetAttributeFromMember(builder, typeof(DerClass), "P4") as ImportAttribute;
Assert.NotNull(importAttribute);
Assert.Null(importAttribute.ContractName);
}
static partial void AddPlatformSpecificConventions( ConventionBuilder builder )
{
var assembly = new PublicKeyTokenSpecification( typeof( Host ) );
var page = new PageSpecification();
var userControl = new UserControlSpecification();
builder.ForTypesMatching( page.IsSatisfiedBy ).Export().Export<Page>().ExportInterfaces( assembly.IsSatisfiedBy ).ImportProperties( p => p != null && p.Name == "Model" );
builder.ForTypesMatching( userControl.IsSatisfiedBy ).Export().ExportInterfaces( assembly.IsSatisfiedBy ).ImportProperties( p => p != null && p.Name == "Model" );
AddWinRTSpecificConventions( builder );
}
public void ImportPropertyTargetingBaseClass_ShouldGenerateImportManyForP3Selected()
{
var builder = new ConventionBuilder();
builder.ForType<DerClass>().ImportProperties((p) => p.Name == "P3"); // P2 is Enumerable
var pAttr = GetAttributeFromMember(builder, typeof(DerClass), "P3") as ImportManyAttribute;
Assert.NotNull(pAttr); // Ensure P3 has ImportManyAttribute (default configured)
Assert.Null(pAttr.ContractName);
}
public void ImportPropertyTargetingDerivedClass_ShouldGenerateImportAttributeForP4Selected()
{
var builder = new ConventionBuilder();
builder.ForType<DerClass>().ImportProperties((p) => p.Name == "P4"); // P1 is string
var pAttr = GetAttributeFromMember(builder, typeof(DerClass), "P4") as ImportAttribute;
Assert.NotNull(pAttr); // Ensure P1 has ImportAttribute (default configured)
Assert.Null(pAttr.ContractName);
}
public void WhenExportingInterfaces_PredicateSpecified_OnlyContractInterfacesAreSeenByThePredicate()
{
var seenInterfaces = new List<Type>();
var builder = new ConventionBuilder();
builder.ForType<ClassWithLifetimeConcerns>().ExportInterfaces(i => { seenInterfaces.Add(i); return true; });
var attributes = GetExportAttributes(builder, typeof(ClassWithLifetimeConcerns));
AssertX.Equivalent(s_contractInterfaces, seenInterfaces);
}
public static void BuildMefConventions(ConventionBuilder conventionBuilder)
{
Contract.Requires(conventionBuilder != null);
// Export views as FrameworkElement with contract name as the type full name, so the ViewLocator can find it.
conventionBuilder.ForTypesMatching(t => t.Name.EndsWith("View"))
.Export<FrameworkElement>(
builder =>
builder.AsContractName(t => t.FullName));
}
