/// <summary>Initializes a new instance of the <see cref="AspNetMvcDependencyResolver"/> class.</summary>
/// <param name="compositionContext">The composition context.</param>
public AspNetMvcDependencyResolver(CompositionContext compositionContext)
{
_compositionContext = compositionContext;
var factory = new AspNetMvcControllerFactory(_compositionContext);
_compositionContext.AddPart<IControllerFactory, AspNetMvcControllerFactory>(factory);
}
public static void Add(CompositionContext compositionContext)
{
if (CompositionContexts.ContainsKey(compositionContext.Name))
CompositionContexts.Remove(compositionContext.Name);
CompositionContexts.Add(compositionContext.Name, compositionContext);
}
public void When_adding_by_type_then_object_should_automatically_be_instantiated()
{
var ctx = new CompositionContext();
ctx.AddPart<ExportClass, ExportClass>();
var obj = new ImportClass();
ctx.SatisfyImports(obj);
Assert.IsTrue(obj.Object != null);
}
/// <summary>Gets the part.</summary>
/// <param name="ctx">The context.</param>
/// <returns>The part. </returns>
public object GetPart(CompositionContext ctx)
{
if (PerRequest)
return CreatePart(ctx);
if (_part == null)
{
lock (_lock)
{
if (_part == null)
{
var part = CreatePart(ctx);
SetPart(ctx, part);
}
}
}
return _part;
}
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 );
}
/// <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());
}
private object CreatePart(CompositionContext ctx)
{
#if !LEGACY
var constructor = Type
.GetTypeInfo()
.DeclaredConstructors
.First();
#else
var constructor = Type
.GetConstructors()
.First();
#endif
var parameters = constructor
.GetParameters()
.Select(p => ctx.GetPart(p.ParameterType, null))
.ToArray();
var part = constructor.Invoke(parameters);
return part;
}
public void Build(CompositionContext context) {
var scope = new CompositionContext(ident, context) { IsChained = true };
// TODO: Again this looks very wrong!
scope.Builder.Build(scope);
}
public SystemCompositionServiceLocator(CompositionContext host)
{
_host = host;
Thread.MemoryBarrier();
ServiceLocator.SetLocatorProvider(() => this);
}
/// <summary>
///
/// </summary>
/// <param name="container"></param>
private static void Test1(CompositionContext container)
{
var test = container.GetExport<LoggerTest>();
test.WriteLog();
}
IEnumerable IExtensible.Extend(CompositionContext context) => _textConverter.Extend(context);
/// <inheritdoc/>
public override void BeginContext(CompositionContext context, Boolean force)
{
if (CurrentContext == context && !force)
return;
var gfx = Ultraviolet.GetGraphics();
switch (context)
{
case CompositionContext.Scene:
{
Compose();
gfx.SetRenderTarget(rtScene);
gfx.Clear(Color.Transparent, 1.0f, 0);
}
break;
case CompositionContext.Interface:
{
gfx.SetRenderTarget(rtInterface);
gfx.Clear(Color.Transparent, 1.0f, 0);
}
break;
case CompositionContext.Overlay:
{
gfx.SetRenderTarget(rtInterface);
}
break;
default:
throw new ArgumentException(nameof(context));
}
base.BeginContext(context);
}
public void InterfaceExport( CompositionContext host )
{
Assert.Same( AssemblyInformationSource.Default, host.GetExport<IParameterizedSource<Assembly, AssemblyInformation>>() );
}
public IEnumerable <TFormat> Extend(CompositionContext context)
{
TFormat[] extensions = context.GetExports <TFormat>().ToArray();
AddRange(extensions);
return(extensions);
}
/// <summary>
/// Initializes a new instance of the <see cref="ExportProviderAdapter"/> class.
/// </summary>
/// <param name="context">The context providing the exports.</param>
public ExportProviderAdapter([NotNull] CompositionContext context)
{
_context = context;
}
/// <summary>
/// Prepares the compositor for the specified composition context.
/// </summary>
/// <param name="context">The <see cref="CompositionContext"/> to which the compositor should transition.</param>
/// <param name="force">A value indicating whether to force the compositor to prepare the device for
/// the specified context, even if the compositor thinks the device is already prepared for the context.</param>
public virtual void BeginContext(CompositionContext context, Boolean force = false)
{
this.currentContext = context;
}
IEnumerable IExtensible.Extend(CompositionContext context) => Extend(context);
public IEnumerable <TMedia> Extend(CompositionContext context) => MediaCatalog.Extend(context);
public MefHostServices(CompositionContext compositionContext)
{
_compositionContext = compositionContext;
}
public static IEnumerable <Lazy <TExtension, TMetadata> > TryGetExports <TExtension, TMetadata>(this CompositionContext compositionContext)
{
try
{
return(compositionContext.GetExports <Lazy <TExtension, TMetadata> >());
}
catch (Exception)
{
return(null);
}
}
public MefHostServices(CompositionContext compositionContext) =>
IEnumerable <IDocumentOutput <string> > IExtensible <IDocumentOutput <string> > .Extend(CompositionContext context) => ExtensibleOutputs.Extend(context);
public ModelShapeBuilder Builder(IContent model,CompositionContext context) {
var paradigms = context.Get<ContentList,ParadigmsContext>();
var builder = _origami.ContentBuilder(model).WithDisplayType(context.Get<ContentList, ShapeMetadata>().DisplayType);
if (paradigms != null) {
builder.WithParadigms(paradigms);
}
return builder;
}
protected override bool IsInScope(CompositionContext context) {
return (context.Identifier == _ident);
}
public void When_loading_objects_from_assembly_then_they_should_be_accessible()
{
var ctx = new CompositionContext();
ctx.AddPartsFromAssembly(GetType().GetTypeInfo().Assembly);
var obj = new ImportClass2();
ctx.SatisfyImports(obj);
Assert.IsTrue(obj.Object1 != null);
}
public MefServiceLocator(CompositionContext container)
{
this.container = container;
}
IEnumerable <IDocumentWriter> IExtensible <IDocumentWriter> .Extend(CompositionContext context) => ExtensibleWriters.Extend(context);
public virtual void Build(CompositionContext context) {
_Locked = true;
foreach (var builder in Builders) {
builder.Build(context);
}
}
/// <summary>Sets the part.</summary>
/// <param name="ctx">The context.</param>
/// <param name="part">The part.</param>
public void SetPart(CompositionContext ctx, object part)
{
ctx.SatisfyImports(_part);
lock (_lock)
_part = part;
}
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 );
}
/// <summary>
/// DissonantLeapRuleEvaluator constructor.
/// </summary>
/// <param name="scaleDegreeEvaluator">The ScaleDegreeEvaluator to use</param>
/// <param name="context">The CompositionContext to use</param>
public DissonantLeapRuleEvaluator(ScaleDegreeEvaluator scaleDegreeEvaluator, CompositionContext context)
{
_scaleDegreeEvaluator = scaleDegreeEvaluator;
_context = context;
}
public void When_adding_object_and_name_then_it_should_be_loadable()
{
var ctx = new CompositionContext();
var part1 = new ExportClass();
var part2 = new ExportClass();
ctx.AddPart<ExportClass, ExportClass>(part1, "1");
ctx.AddPart<ExportClass, ExportClass>(part2, "2");
var obj = new ImportClass2();
ctx.SatisfyImports(obj);
Assert.AreEqual(part1, obj.Object1);
Assert.AreEqual(part2, obj.Object2);
}
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 );
}
public void When_instantiating_class_with_ctor_arguments_then_the_needed_objects_get_created()
{
var ctx = new CompositionContext();
ctx.AddPart<ExportClass1, ExportClass1>();
ctx.AddPart<ExportClassWithCtor, ExportClassWithCtor>();
var part = ctx.GetPart<ExportClassWithCtor>();
Assert.IsNotNull(part.Import);
Assert.AreEqual(part.Import, ctx.GetPart<ExportClass1>());
}
public void ExportWhenAlreadyRegistered( CompositionContext host )
{
var item = host.GetExport<ExportedItem>();
Assert.IsType<ExportedItem>( item );
Assert.False( Condition.Default.Get( item ).IsApplied );
}
public void When_adding_object_then_it_should_be_loadable()
{
var ctx = new CompositionContext();
var part = new ExportClass();
ctx.AddPart<ExportClass, ExportClass>(part);
var obj = new ImportClass();
ctx.SatisfyImports(obj);
Assert.AreEqual(part, obj.Object);
}
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 void Composition( CompositionContext host )
{
var item = host.GetExport<ExportedItem>();
Assert.NotNull( item );
Assert.False( Condition.Default.Get( item ).IsApplied );
}
public void VerifyInstanceExport( CompositionContext host, [Service]ImmutableArray<Assembly> assemblies )
{
var composed = host.GetExport<ImmutableArray<Assembly>>();
Assert.Equal( assemblies, composed );
}
protected override bool IsInScope(CompositionContext context) {
return !context.IsChained;
}
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 );
}
/// <summary>Initializes a new instance of the <see cref="AspNetMvcControllerFactory"/> class.</summary>
/// <param name="compositionContext">The composition context.</param>
public AspNetMvcControllerFactory(CompositionContext compositionContext)
{
_compositionContext = compositionContext;
}
/// <summary>
///
/// </summary>
/// <param name="container"></param>
private static void Test1(CompositionContext container)
{
var test = container.GetExport <LoggerTest>();
test.WriteLog();
}
