Dreamine.FullKit.Tests.Core.DreamineContainerTests 클래스 참조

더 자세히 ...

클래스
interface	IClock
class	FixedClock
class	AlternateClock
class	SlowSingleton
class	IndependentA
class	IndependentB
class	ReportService
class	CircularA
class	CircularB
class	AutoRegistrationViewModel
class	DisposableSingleton

Public 멤버 함수
void	Resolve_CreatesRegisteredTransientWithConstructorDependencies ()
void	Resolve_ReusesRegisteredSingletonImplementation ()
void	Resolve_CreatesUnregisteredConcreteType ()
void	Resolve_ThrowsForUnregisteredInterface ()
void	Resolve_DetectsCircularDependencies ()
async Task	Resolve_CreatesSingletonOnlyOnceAcrossConcurrentCalls ()
async Task	Resolve_DoesNotShareCircularStateAcrossConcurrentCalls ()
void	Register_ReplacesPreviousSingletonCache ()
void	DreamineAutoRegistrar_RegisterAll_SingleAssemblyOverload_RegistersInDMContainer ()
void	DMContainer_ResetClearsStaticFacadeRegistrations ()
void	DreamineContainer_Dispose_DisposesIDisposableSingletons ()
void	DreamineContainer_Dispose_IsIdempotent ()
void	DMContainer_Reset_DisposesOldContainerSingletons ()

상세한 설명

Dreamine Container Tests 기능과 관련 상태를 캡슐화합니다.

DreamineContainerTests.cs 파일의 136 번째 라인에서 정의되었습니다.

멤버 함수 문서화

DMContainer_Reset_DisposesOldContainerSingletons()

void Dreamine.FullKit.Tests.Core.DreamineContainerTests.DMContainer_Reset_DisposesOldContainerSingletons ( )

inline

DM Container Reset Disposes Old Container Singletons 작업을 수행합니다.

DreamineContainerTests.cs 파일의 426 번째 라인에서 정의되었습니다.

    {
        DMContainer.Reset();
        var disposable = new DisposableSingleton();
        DMContainer.RegisterSingleton(disposable);
 
        _ = DMContainer.Resolve<DisposableSingleton>();
        Assert.False(disposable.IsDisposed);
 
        DMContainer.Reset();
 
        Assert.True(disposable.IsDisposed);
    }

DMContainer_ResetClearsStaticFacadeRegistrations()

void Dreamine.FullKit.Tests.Core.DreamineContainerTests.DMContainer_ResetClearsStaticFacadeRegistrations ( )

inline

DM Container Reset Clears Static Facade Registrations 작업을 수행합니다.

DreamineContainerTests.cs 파일의 361 번째 라인에서 정의되었습니다.

    {
        DMContainer.Reset();
        DMContainer.Register<IClock, FixedClock>();
 
        Assert.True(DMContainer.IsRegistered<IClock>());
 
        DMContainer.Reset();
 
        Assert.False(DMContainer.IsRegistered<IClock>());
    }

DreamineAutoRegistrar_RegisterAll_SingleAssemblyOverload_RegistersInDMContainer()

void Dreamine.FullKit.Tests.Core.DreamineContainerTests.DreamineAutoRegistrar_RegisterAll_SingleAssemblyOverload_RegistersInDMContainer ( )

inline

Dreamine Auto Registrar Register All Single Assembly Overload Registers In DM Container 작업을 수행합니다.

DreamineContainerTests.cs 파일의 341 번째 라인에서 정의되었습니다.

    {
        DMContainer.Reset();
 
        // The no-registry overload scans the given assembly and registers into DMContainer directly.
        Dreamine.MVVM.Core.DreamineAutoRegistrar.RegisterAll(typeof(DreamineContainerTests).Assembly);
 
        // AutoRegistrationViewModel matches the naming convention filter used by DreamineAutoRegistrar.
        Assert.True(DMContainer.IsRegistered<AutoRegistrationViewModel>());
    }

DreamineContainer_Dispose_DisposesIDisposableSingletons()

void Dreamine.FullKit.Tests.Core.DreamineContainerTests.DreamineContainer_Dispose_DisposesIDisposableSingletons ( )

inline

Dreamine Container Dispose Disposes I Disposable Singletons 작업을 수행합니다.

DreamineContainerTests.cs 파일의 382 번째 라인에서 정의되었습니다.

    {
        var container = new DreamineContainer();
        var disposable = new DisposableSingleton();
        container.RegisterSingleton<DisposableSingleton>(disposable);
 
        _ = container.Resolve<DisposableSingleton>();
        Assert.False(disposable.IsDisposed);
 
        container.Dispose();
 
        Assert.True(disposable.IsDisposed);
    }

다음을 참조함 : Dreamine.FullKit.Tests.Core.DreamineContainerTests.DisposableSingleton.Dispose().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

DreamineContainer_Dispose_IsIdempotent()

void Dreamine.FullKit.Tests.Core.DreamineContainerTests.DreamineContainer_Dispose_IsIdempotent ( )

inline

Dreamine Container Dispose Is Idempotent 작업을 수행합니다.

DreamineContainerTests.cs 파일의 405 번째 라인에서 정의되었습니다.

    {
        var container = new DreamineContainer();
        var disposable = new DisposableSingleton();
        container.RegisterSingleton<DisposableSingleton>(disposable);
 
        container.Dispose();
        container.Dispose();
 
        Assert.Equal(1, disposable.DisposeCount);
    }

다음을 참조함 : Dreamine.FullKit.Tests.Core.DreamineContainerTests.DisposableSingleton.Dispose().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

Register_ReplacesPreviousSingletonCache()

void Dreamine.FullKit.Tests.Core.DreamineContainerTests.Register_ReplacesPreviousSingletonCache ( )

inline

Register Replaces Previous Singleton Cache 작업을 수행합니다.

DreamineContainerTests.cs 파일의 318 번째 라인에서 정의되었습니다.

    {
        var container = new DreamineContainer();
        container.RegisterSingleton<IClock, FixedClock>();
 
        _ = container.Resolve<IClock>();
 
        container.Register<IClock, AlternateClock>();
 
        var resolved = container.Resolve<IClock>();
 
        Assert.IsType<AlternateClock>(resolved);
    }

Resolve_CreatesRegisteredTransientWithConstructorDependencies()

void Dreamine.FullKit.Tests.Core.DreamineContainerTests.Resolve_CreatesRegisteredTransientWithConstructorDependencies ( )

inline

Resolve Creates Registered Transient With Constructor Dependencies 작업을 수행합니다.

DreamineContainerTests.cs 파일의 147 번째 라인에서 정의되었습니다.

    {
        var container = new DreamineContainer();
        container.Register<IClock, FixedClock>();
        container.Register<ReportService>();
 
        var first = container.Resolve<ReportService>();
        var second = container.Resolve<ReportService>();
 
        Assert.NotSame(first, second);
        Assert.IsType<FixedClock>(first.Clock);
        Assert.Equal("2026-06-07", first.CreateReportName());
    }

Resolve_CreatesSingletonOnlyOnceAcrossConcurrentCalls()

async Task Dreamine.FullKit.Tests.Core.DreamineContainerTests.Resolve_CreatesSingletonOnlyOnceAcrossConcurrentCalls ( )

inline

Resolve Creates Singleton Only Once Across Concurrent Calls 작업을 수행합니다.

반환값

Resolve Creates Singleton Only Once Across Concurrent Calls 작업에서 생성한 Task 결과입니다.

DreamineContainerTests.cs 파일의 256 번째 라인에서 정의되었습니다.

    {
        SlowSingleton.Reset();
 
        var container = new DreamineContainer();
        container.RegisterSingleton<SlowSingleton>();
 
        var tasks = Enumerable.Range(0, 32)
            .Select(_ => Task.Run(() => container.Resolve<SlowSingleton>()))
            .ToArray();
 
        var instances = await Task.WhenAll(tasks);
 
        Assert.Single(instances.Distinct());
        Assert.Equal(1, SlowSingleton.CreatedCount);
    }

다음을 참조함 : Dreamine.FullKit.Tests.Core.DreamineContainerTests.SlowSingleton.CreatedCount, Dreamine.FullKit.Tests.Core.DreamineContainerTests.SlowSingleton.Reset().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

Resolve_CreatesUnregisteredConcreteType()

void Dreamine.FullKit.Tests.Core.DreamineContainerTests.Resolve_CreatesUnregisteredConcreteType ( )

inline

Resolve Creates Unregistered Concrete Type 작업을 수행합니다.

DreamineContainerTests.cs 파일의 190 번째 라인에서 정의되었습니다.

    {
        var container = new DreamineContainer();
 
        var instance = container.Resolve<FixedClock>();
 
        Assert.Equal(new DateOnly(2026, 6, 7), instance.Today);
    }

Resolve_DetectsCircularDependencies()

void Dreamine.FullKit.Tests.Core.DreamineContainerTests.Resolve_DetectsCircularDependencies ( )

inline

Resolve Detects Circular Dependencies 작업을 수행합니다.

DreamineContainerTests.cs 파일의 227 번째 라인에서 정의되었습니다.

    {
        var container = new DreamineContainer();
        container.Register<CircularA>();
        container.Register<CircularB>();
 
        var exception = Assert.Throws<InvalidOperationException>(
            () => container.Resolve<CircularA>());
 
        Assert.Contains("Circular dependency", exception.Message);
    }

Resolve_DoesNotShareCircularStateAcrossConcurrentCalls()

async Task Dreamine.FullKit.Tests.Core.DreamineContainerTests.Resolve_DoesNotShareCircularStateAcrossConcurrentCalls ( )

inline

Resolve Does Not Share Circular State Across Concurrent Calls 작업을 수행합니다.

반환값

Resolve Does Not Share Circular State Across Concurrent Calls 작업에서 생성한 Task 결과입니다.

DreamineContainerTests.cs 파일의 290 번째 라인에서 정의되었습니다.

    {
        var container = new DreamineContainer();
        container.Register<IndependentA>();
        container.Register<IndependentB>();
 
        var tasks = Enumerable.Range(0, 16)
            .Select(index => Task.Run<object>(() =>
                index % 2 == 0
                    ? container.Resolve<IndependentA>()
                    : container.Resolve<IndependentB>()))
            .ToArray();
 
        var instances = await Task.WhenAll(tasks);
 
        Assert.Equal(16, instances.Length);
        Assert.All(instances, Assert.NotNull);
    }

Resolve_ReusesRegisteredSingletonImplementation()

void Dreamine.FullKit.Tests.Core.DreamineContainerTests.Resolve_ReusesRegisteredSingletonImplementation ( )

inline

Resolve Reuses Registered Singleton Implementation 작업을 수행합니다.

DreamineContainerTests.cs 파일의 170 번째 라인에서 정의되었습니다.

    {
        var container = new DreamineContainer();
        container.RegisterSingleton<IClock, FixedClock>();
 
        var first = container.Resolve<IClock>();
        var second = container.Resolve<IClock>();
 
        Assert.Same(first, second);
    }

Resolve_ThrowsForUnregisteredInterface()

void Dreamine.FullKit.Tests.Core.DreamineContainerTests.Resolve_ThrowsForUnregisteredInterface ( )

inline

Resolve Throws For Unregistered Interface 작업을 수행합니다.

DreamineContainerTests.cs 파일의 208 번째 라인에서 정의되었습니다.

    {
        var container = new DreamineContainer();
 
        var exception = Assert.Throws<InvalidOperationException>(
            () => container.Resolve<IClock>());
 
        Assert.Contains("is not registered", exception.Message);
    }

---

이 클래스에 대한 문서화 페이지는 다음의 파일로부터 생성되었습니다.:

• DreamineContainerTests.cs