/// <inheritdoc />
Task <object?> IUnityContainerAsync.Resolve(Type type, string?name, params ResolverOverride[] overrides)
{
// Setup Context
var registration = GetRegistration(type ?? throw new ArgumentNullException(nameof(type)), name);
// Check if pipeline exists
if (null == registration.Pipeline)
{
// Start a new Task to create and execute pipeline
return(Task.Factory.StartNew(() =>
{
var context = new BuilderContext
{
List = new PolicyList(),
Type = type,
Overrides = overrides,
Registration = registration,
ContainerContext = Context,
};
return context.Pipeline(ref context);
}));
}
// Existing pipeline
var context = new BuilderContext
{
Async = true,
List = new PolicyList(),
Type = type,
Overrides = overrides,
Registration = registration,
ContainerContext = Context,
};
// Execute the pipeline
var task = context.Pipeline(ref context);
// Make sure it is indeed a Task
Debug.Assert(task is Task <object?>);
// Return Task
return((Task <object?>)task);
}
ValueTask <object?> IUnityContainerAsync.ResolveAsync(Type type, string?name, params ResolverOverride[] overrides)
{
var registration = GetRegistration(type ?? throw new ArgumentNullException(nameof(type)), name);
if (null != registration.LifetimeManager)
{
// Make unblocking check if already has result
var value = registration.LifetimeManager.TryGet(LifetimeContainer);
if (LifetimeManager.NoValue != value)
{
return(new ValueTask <object?>(value));
}
}
return(new ValueTask <object?>(Task.Factory.StartNew <object?>(delegate
{
// Check if already created and acquire a lock
if (null != registration.LifetimeManager)
{
var value = registration.LifetimeManager.Get(LifetimeContainer);
if (LifetimeManager.NoValue != value)
{
return new ValueTask <object?>(value);
}
}
// Setup Context
var synchronized = registration.LifetimeManager as SynchronizedLifetimeManager;
var context = new BuilderContext
{
List = new PolicyList(),
Type = type,
Name = name,
Overrides = overrides,
Registration = registration,
ContainerContext = Context,
};
// Execute pipeline
try
{
var value = context.Pipeline(ref context);
registration.LifetimeManager?.Set(value, LifetimeContainer);
return value;
}
catch (Exception ex)
{
synchronized?.Recover();
if (ex is InvalidRegistrationException ||
ex is CircularDependencyException ||
ex is ObjectDisposedException)
{
var message = CreateErrorMessage(ex);
throw new ResolutionFailedException(context.Type, context.Name, message, ex);
}
else
{
throw;
}
}
})));
}
/// <inheritdoc />
Task <object?> IUnityContainerAsync.Resolve(Type type, string?name, params ResolverOverride[] overrides)
{
// Setup Context
var registration = GetRegistration(type ?? throw new ArgumentNullException(nameof(type)), name);
// Check if pipeline exists
if (null == registration.Pipeline)
{
// Start a new Task to create and execute pipeline
return(Task.Factory.StartNew(() =>
{
var context = new BuilderContext
{
List = new PolicyList(),
Type = type,
Overrides = overrides,
Registration = registration,
ContainerContext = Context,
};
try
{
// Execute pipeline
return context.Pipeline(ref context);
}
catch (Exception ex)
when(ex is InvalidRegistrationException ||
ex is CircularDependencyException ||
ex is ObjectDisposedException)
{
var message = CreateMessage(ex);
throw new ResolutionFailedException(context.Type, context.Name, message, ex);
}
}));
}
// Existing pipeline
var context = new BuilderContext
{
Async = true,
List = new PolicyList(),
Type = type,
Overrides = overrides,
Registration = registration,
ContainerContext = Context,
};
try
{
// Execute pipeline
var task = context.Pipeline(ref context);
// Make sure it is indeed a Task
Debug.Assert(task is Task <object?>);
// Return Task
return((Task <object?>)task);
}
catch (Exception ex)
when(ex is InvalidRegistrationException || ex is CircularDependencyException)
{
var message = CreateMessage(ex);
throw new ResolutionFailedException(context.Type, context.Name, message, ex);
}
}