/// <summary>
/// Activates the job.
/// </summary>
/// <param name="type">The type.</param>
/// <returns></returns>
public override object ActivateJob(Type type)
{
if (type == typeof(ScheduleActionJob))
{
return(new ScheduleActionJob(_context.GetExport <ProjectManager>(), _context.GetExport <WorkflowInvoker>()));
}
if (type == typeof(MailJobClient))
{
var client = new MailJobClient(new SmtpClient());
client.LogManager = _context.GetExport <LogManager>();
return(client);
}
if (type == typeof(CommandListenerJob))
{
return(new CommandListenerJob(_context.GetExport <CommandClient>()));
}
if (type == typeof(CommandCleanerJob))
{
return(new CommandCleanerJob(_context.GetExport <CommandManager>()));
}
return(null);
}
public INancyEngine GetEngine()
{
if (!_initialised)
{
throw new InvalidOperationException("Bootstrapper is not initialised. Call Initialise before GetEngine");
}
var engine = ApplicationContainer.GetExport <INancyEngine>();
engine.RequestPipelinesFactory = InitializeRequestPipelines;
return(engine);
}
/// <summary>
/// SharingBoundary,Sharedテスト
/// </summary>
/// <param name="container"></param>
private static void Test2(CompositionContext container)
{
var factory = container.GetExport <ShareFactory>();
ShareTest test1, test2, test3;
using (var ctx = factory.Factory.CreateExport())
{
if (container == ctx.Value)
{
System.Diagnostics.Debug.WriteLine("Container same");
}
else
{
System.Diagnostics.Debug.WriteLine("Container not same");
}
test1 = ctx.Value.GetExport <ShareTest>();
if (test1.Child == test1.Parent.Child)
{
System.Diagnostics.Debug.WriteLine("Child same (test1-test1.Child)");
}
else
{
System.Diagnostics.Debug.WriteLine("Child not same (test1-test1.Child)");
}
test2 = ctx.Value.GetExport <ShareTest>();
if (test1.Child == test2.Child)
{
System.Diagnostics.Debug.WriteLine("Child same (test1-test2)");
}
else
{
System.Diagnostics.Debug.WriteLine("Child not same (test1-test2)");
}
}
using (var ctx = factory.Factory.CreateExport())
{
test3 = ctx.Value.GetExport <ShareTest>();
if (test1.Child == test3.Child)
{
System.Diagnostics.Debug.WriteLine("Child same (test1-test3)");
}
else
{
System.Diagnostics.Debug.WriteLine("Child not same (test1-test3)");
}
var logger = ctx.Value.GetExport <LoggerTest>();
logger.WriteLog();
}
}
public void BasicCompose( CompositionContext host )
{
var serviceProvider = DefaultServices.Default.Cached();
var sinkOne = host.GetExport<ILoggerHistory>();
var sinkTwo = host.GetExport<ILoggerHistory>();
Assert.Same( sinkOne, sinkTwo );
Assert.Same( serviceProvider.Get<ILoggerHistory>(), sinkOne );
var first = host.GetExport<ILogger>();
var second = host.GetExport<ILogger>();
Assert.Same( first, second );
Assert.Same( serviceProvider.Get<ILogger>(), first );
Assert.Empty( sinkOne.Events );
var current = sinkOne.Events.Count();
first.Information( "Testing this out." );
Assert.NotEmpty( sinkOne.Events );
Assert.True( sinkOne.Events.Count() > current );
}
private static void GetExport()
{
CompositionContext cc = CreateContainer(typeof(A), typeof(B), typeof(C), typeof(D));
D d = cc.GetExport <D>();
Assert.IsAssignableFrom <A>(d.A);
Assert.IsAssignableFrom <B>(d.B);
Assert.IsAssignableFrom <A>(d.B.A);
Assert.IsAssignableFrom <C>(d.C);
Assert.IsAssignableFrom <A>(d.C.A);
Assert.IsAssignableFrom <B>(d.C.B);
}
public CompositionContextProvider(CompositionContext rootCompositionContext)
{
if (rootCompositionContext == null)
{
throw new ArgumentNullException("rootCompositionContext");
}
// Create factory
var contract = new CompositionContract(typeof(ExportFactory <CompositionContext>), null, new Dictionary <string, object>()
{
{ Constants.SharingBoundaryNameKey, new string[] { Constants.InstancePerRequestBoundaryName } }
});
_compositionContextFactory = (ExportFactory <CompositionContext>)rootCompositionContext.GetExport(contract);
}
protected virtual CompositionContext CreateRequestContainer(NancyContext context, CompositionContext parentContainer)
{
if (RequestContainerFactory == null)
{
var rcfContract = new CompositionContract(
typeof(ExportFactory <CompositionContext>),
null,
new Dictionary <string, object> {
{ "SharingBoundaryNames", new[] { PerRequestBoundary } }
});
RequestContainerFactory = (ExportFactory <CompositionContext>)parentContainer.GetExport(rcfContract);
}
return(RequestContainerFactory.CreateExport().Value);
}
/// <summary>
/// SharingBoundary,Sharedテスト
/// </summary>
/// <param name="container"></param>
private static void Test2(CompositionContext container)
{
var factory = container.GetExport<ShareFactory>();
ShareTest test1, test2, test3;
using (var ctx = factory.Factory.CreateExport())
{
if (container == ctx.Value)
System.Diagnostics.Debug.WriteLine("Container same");
else
System.Diagnostics.Debug.WriteLine("Container not same");
test1 = ctx.Value.GetExport<ShareTest>();
if (test1.Child == test1.Parent.Child)
System.Diagnostics.Debug.WriteLine("Child same (test1-test1.Child)");
else
System.Diagnostics.Debug.WriteLine("Child not same (test1-test1.Child)");
test2 = ctx.Value.GetExport<ShareTest>();
if (test1.Child == test2.Child)
System.Diagnostics.Debug.WriteLine("Child same (test1-test2)");
else
System.Diagnostics.Debug.WriteLine("Child not same (test1-test2)");
}
using (var ctx = factory.Factory.CreateExport())
{
test3 = ctx.Value.GetExport<ShareTest>();
if (test1.Child == test3.Child)
System.Diagnostics.Debug.WriteLine("Child same (test1-test3)");
else
System.Diagnostics.Debug.WriteLine("Child not same (test1-test3)");
var logger = ctx.Value.GetExport<LoggerTest>();
logger.WriteLog();
}
}
/// <summary>
/// Initialize the composition provider.
/// </summary>
/// <param name="applicationContext">A container supplying composed parts.</param>
public static void Initialize(CompositionContext applicationContext)
{
if (applicationContext == null) throw new ArgumentNullException("applicationContext");
lock (_initLock)
{
if (_applicationContext != null) throw new InvalidOperationException("Composition provider is already initialized.");
_applicationContext = applicationContext;
}
var rcfContract = new CompositionContract(
typeof(ExportFactory<CompositionContext>),
null,
new Dictionary<string, object> {
{ "SharingBoundaryNames", new[] { Boundaries.HttpContext, Boundaries.DataConsistency, Boundaries.UserIdentity }}
});
_requestContextFactory = (ExportFactory<CompositionContext>)_applicationContext.GetExport(rcfContract);
DependencyResolver.SetResolver(new ComposedDependencyResolver());
}
protected override object DoGetInstance(Type serviceType, string key)
{
return(_host.GetExport(serviceType, key));
}
/// <summary>
///
/// </summary>
/// <param name="container"></param>
private static void Test1(CompositionContext container)
{
var test = container.GetExport<LoggerTest>();
test.WriteLog();
}
T IExportProvider.GetExportedValue <T>([CanBeNull] string contractName)
{
return(_context.GetExport <T>(contractName));
}
public static object?GetExport(CompositionContext?compositionContext, Type?viewType) => viewType is null ? null : compositionContext?.GetExport(viewType);
public void ExportWhenAlreadyRegistered( CompositionContext host )
{
var item = host.GetExport<ExportedItem>();
Assert.IsType<ExportedItem>( item );
Assert.False( Condition.Default.Get( item ).IsApplied );
}
public void InterfaceExport( CompositionContext host )
{
Assert.Same( AssemblyInformationSource.Default, host.GetExport<IParameterizedSource<Assembly, AssemblyInformation>>() );
}
public void SharedComposition( CompositionContext host )
{
var service = host.GetExport<ISharedService>();
Assert.IsType<SharedService>( service );
Assert.Same( service, host.GetExport<ISharedService>() );
Assert.True( Condition.Default.Get( service ).IsApplied );
}
public void BasicCompositionWithParameter( CompositionContext host, string text )
{
var test = host.GetExport<IParameterService>();
var parameter = Assert.IsType<Parameter>( test.Parameter );
Assert.Equal( "WithInstance by ParameterService", parameter.Message );
}
public void VerifyInstanceExport( CompositionContext host, [Service]ImmutableArray<Assembly> assemblies )
{
var composed = host.GetExport<ImmutableArray<Assembly>>();
Assert.Equal( assemblies, composed );
}
public void Composition( CompositionContext host )
{
var item = host.GetExport<ExportedItem>();
Assert.NotNull( item );
Assert.False( Condition.Default.Get( item ).IsApplied );
}
public void FactoryInstance( CompositionContext host )
{
var service = host.GetExport<IBasicService>();
Assert.IsType<BasicService>( service );
Assert.NotSame( service, host.GetExport<IBasicService>() );
Assert.True( Condition.Default.Get( service ).IsApplied );
var factory = host.GetExport<Func<IBasicService>>();
Assert.NotNull( factory );
var created = factory();
Assert.NotSame( factory, service );
Assert.IsType<BasicService>( created );
Assert.True( Condition.Default.Get( created ).IsApplied );
}
public object GetService(Type serviceType)
{
return(_host.GetExport(serviceType));
}
T IExportProvider.GetExportedValue <T>([CanBeNull] string?contractName) where T : class
{
return(_context.GetExport <T>(contractName));
}
/// <summary>
///
/// </summary>
/// <param name="container"></param>
private static void Test1(CompositionContext container)
{
var test = container.GetExport <LoggerTest>();
test.WriteLog();
}
public void FactoryWithParameterDelegate( CompositionContext host, string message )
{
var factory = host.GetExport<Func<Parameter, IParameterService>>();
Assert.NotNull( factory );
var parameter = new Parameter();
var created = factory( parameter );
Assert.Same( parameter, created.Parameter );
Assert.Equal( "WithInstance by ParameterService", parameter.Message );
var test = host.GetExport<IParameterService>();
var p = Assert.IsType<Parameter>( test.Parameter );
Assert.Equal( "WithInstance by ParameterService", p.Message );
Assert.NotSame( parameter, p );
}
