public void FunctionalLifeSpanTest_ShouldProduceDesiredResults()
{
// Arrange.
var disposableObjectCount = 30;
var disposableObjects = new SimulatedInstrument[disposableObjectCount];
var target = new ReferenceManager();
for (var i = 0; i < disposableObjectCount; i++)
{
// Arrange.
var disposableObject = new SimulatedInstrument(ConcurrencyControlMode.Unconstrained);
disposableObject.StoreIntegerValue(i);
disposableObjects[i] = disposableObject;
// Act.
target.AddObject(disposableObject);
target.AddObject(new Object());
target.AddObject((Object)null);
// Assert.
target.ObjectCount.Should().Be((i + 1) * 3);
}
// Act.
target.Dispose();
// Assert.
target.ObjectCount.Should().Be(0);
foreach (var disposableObject in disposableObjects)
{
// Assert.
disposableObject.NullableIntegerValue.Should().BeNull();
}
}
private IMessageSubscriptionProfile CreateSubscriptionProfile()
{
var dependencyScope = CreateDependencyScope();
ReferenceManager.AddObject(dependencyScope);
return(new MessageSubscriptionProfile(dependencyScope));
}
private CommandMediator CreateMediator(IComponentContext provider)
{
var lifetimeScope = provider.Resolve <ILifetimeScope>();
var dependencyScope = new AutofacDependencyScope(lifetimeScope);
ReferenceManager.AddObject(dependencyScope);
return(new CommandMediator(dependencyScope));
}
private CommandMediator CreateMediator(IServiceProvider provider)
{
var sourceScope = provider.CreateScope();
var dependencyScope = new DotNetNativeDependencyScope(sourceScope);
ReferenceManager.AddObject(dependencyScope);
return(new CommandMediator(dependencyScope));
}
private void ScheduleHeartbeat(IHeartbeatScheduleItem heartbeatScheduleItem)
{
var timerCallback = new TimerCallback((state) => Task.Factory.StartNew(async() => await PublishHeartbeatMessageAsync(state as IHeartbeatScheduleItem).ConfigureAwait(false)));
var timer = new Timer(timerCallback, heartbeatScheduleItem, TimeSpan.Zero, TimeSpan.FromSeconds(heartbeatScheduleItem.IntervalInSeconds));
HeartbeatTimers.Add(timer);
ReferenceManager.AddObject(timer);
}
/// <summary>
/// Creates a new child initialization and disposal scope for the current <see cref="DependencyScope{TScope}" />.
/// </summary>
/// <returns>
/// A new child initialization and disposal scope for the current <see cref="DependencyScope{TScope}" />.
/// </returns>
/// <exception cref="CreateDependencyScopeException">
/// An exception was raised while attempting to create the scope.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The object is disposed.
/// </exception>
public IDependencyScope CreateChildScope()
{
RejectIfDisposed();
try
{
var childScope = CreateChildScope(SourceScope);
ReferenceManager.AddObject(childScope);
return(childScope);
}
catch (Exception exception)
{
throw new CreateDependencyScopeException(exception);
}
}
internal static IServiceCollection AddDependencyPackage <TConfigurator, TEngine, TPackage>(this IServiceCollection target, IConfiguration applicationConfiguration, out IServiceProvider serviceProvider)
where TConfigurator : class, new()
where TEngine : class, IDependencyEngine
where TPackage : class, IDependencyPackage <TConfigurator, TEngine>, new()
{
if (target.Any(element => element.ServiceType == typeof(IDependencyEngine)))
{
throw new InvalidOperationException("Another dependency package has already been added to the service collection.");
}
var package = new TPackage();
var engine = DependencyEngine.New <TConfigurator, TEngine, TPackage>(applicationConfiguration, target);
ReferenceManager.AddObject(engine);
serviceProvider = engine.Provider;
return(target);
}
/// <summary>
/// Returns the instance of specified type that is managed by the current <see cref="IFactoryProducedInstanceGroup" />.
/// </summary>
/// <typeparam name="T">
/// The type of the instance to return.
/// </typeparam>
/// <returns>
/// The instance of specified type that is managed by the current <see cref="IFactoryProducedInstanceGroup" />.
/// </returns>
/// <exception cref="ArgumentException">
/// <typeparamref name="T" /> is not a supported type for the group.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The object is disposed.
/// </exception>
/// <exception cref="ObjectProductionException">
/// An exception was raised during object production.
/// </exception>
public T Get <T>()
where T : class
{
var instanceType = typeof(T);
using (var controlToken = StateControl.Enter())
{
RejectIfDisposed();
if (Instances.TryGetValue(instanceType, out var extantInstance))
{
return(extantInstance as T);
}
var newInstance = Factory.Produce(instanceType) as T;
Instances.Add(instanceType, newInstance);
ReferenceManager.AddObject(newInstance);
return(newInstance);
}
}
/// <summary>
/// Requests an object of specified type from the associated container for the current <see cref="IDependencyScope" />.
/// </summary>
/// <param name="type">
/// The type of the object to resolve.
/// </param>
/// <returns>
/// An object of specified type from the associated container.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="type" /> is <see langword="null" />.
/// </exception>
/// <exception cref="DependencyResolutionException">
/// An exception was raised while attempting to resolve the dependency.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The object is disposed.
/// </exception>
public Object Resolve(Type type)
{
RejectIfDisposed();
try
{
var resolvedObject = Resolve(SourceScope, type.RejectIf().IsNull(nameof(type)));
if (ManagesReferencesForSourceScope)
{
ReferenceManager.AddObject(resolvedObject);
}
return(resolvedObject);
}
catch (Exception exception)
{
throw new DependencyResolutionException(type, exception);
}
}
/// <summary>
/// Requests an object of specified type from the associated container for the current
/// <see cref="DependencyScope{TScope}" />.
/// </summary>
/// <typeparam name="T">
/// The type of the object to resolve.
/// </typeparam>
/// <returns>
/// An object of specified type from the associated container.
/// </returns>
/// <exception cref="DependencyResolutionException">
/// An exception was raised while attempting to resolve the dependency.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The object is disposed.
/// </exception>
public T Resolve <T>()
where T : class
{
RejectIfDisposed();
try
{
var resolvedObject = Resolve <T>(SourceScope);
if (ManagesReferencesForSourceScope)
{
ReferenceManager.AddObject(resolvedObject);
}
return(resolvedObject);
}
catch (Exception exception)
{
throw new DependencyResolutionException(typeof(T), exception);
}
}
/// <summary>
/// Creates a new initialization and disposal scope for the current
/// <see cref="DependencyContainer{TContainer, TConfigurator}" />.
/// </summary>
/// <returns>
/// A new initialization and disposal scope for the current <see cref="DependencyContainer{TContainer, TConfigurator}" />.
/// </returns>
/// <exception cref="CreateDependencyScopeException">
/// An exception was raised while attempting to create the scope.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The object is disposed.
/// </exception>
public IDependencyScope CreateScope()
{
using (var controlToken = StateControl.Enter())
{
RejectIfDisposed();
try
{
var scope = RootScope.CreateChildScope();
ReferenceManager.AddObject(scope);
return(scope);
}
catch (CreateDependencyScopeException)
{
throw;
}
catch (Exception exception)
{
throw new CreateDependencyScopeException(exception);
}
}
}
