public static P DeliveParam <S, P>(this string serverName, string resolverName, string alias, ResolveDelegate <IParamNotice <P> > newResolver = default, bool isReregister = false) where S : IServer
{
S server = serverName.GetServer <S>();
IParamNotice <P> notice;
if (newResolver != default)
{
if (isReregister)
{
ResolveDelegate <IParamNotice <P> > raw = server.Reregister(newResolver, alias);
notice = server.Delive <IParamNotice <P> >(resolverName, alias);
server.Reregister(raw, alias);
}
else
{
notice = server.Delive <IParamNotice <P> >(resolverName, alias);
newResolver.Invoke(ref notice);
}
}
else
{
notice = server.Delive <IParamNotice <P> >(resolverName, alias);
}
return(notice.ParamValue);
}
protected override ResolveDelegate <BuilderContext> GetPerResolveDelegate(ConstructorInfo info, object?resolvers, ResolveDelegate <BuilderContext>?pipeline)
{
var parameterResolvers = CreateDiagnosticParameterResolvers(info.GetParameters(), resolvers).ToArray();
// PerResolve lifetime
return((ref BuilderContext context) =>
{
if (null == context.Existing)
{
try
{
var dependencies = new object[parameterResolvers.Length];
for (var i = 0; i < dependencies.Length; i++)
{
dependencies[i] = parameterResolvers[i](ref context);
}
context.Existing = info.Invoke(dependencies);
}
catch (Exception ex)
{
ex.Data.Add(Guid.NewGuid(), info);
throw;
}
context.Set(typeof(LifetimeManager),
new InternalPerResolveLifetimeManager(context.Existing));
}
return null == pipeline ? context.Existing : pipeline.Invoke(ref context);
});
}
private static ResolveDelegate <BuilderContext> OptimizingFactory(ref BuilderContext context)
{
var counter = 3;
var type = context.Type;
var registration = context.Registration;
ResolveDelegate <BuilderContext> seed = null;
var chain = ((UnityContainer)context.Container)._processorsChain;
// Generate build chain
foreach (var processor in chain)
{
seed = processor.GetResolver(type, registration, seed);
}
// Return delegate
return((ref BuilderContext c) =>
{
// Check if optimization is required
if (0 == Interlocked.Decrement(ref counter))
{
Task.Factory.StartNew(() => {
// Compile build plan on worker thread
var expressions = new List <Expression>();
foreach (var processor in chain)
{
foreach (var step in processor.GetExpressions(type, registration))
{
expressions.Add(step);
}
}
expressions.Add(BuilderContextExpression.Existing);
var lambda = Expression.Lambda <ResolveDelegate <BuilderContext> >(
Expression.Block(expressions), BuilderContextExpression.Context);
// Replace this build plan with compiled
registration.Set(typeof(ResolveDelegate <BuilderContext>), lambda.Compile());
});
}
return seed?.Invoke(ref c);
});
}
protected virtual ResolveDelegate <BuilderContext> GetResolverDelegate(ConstructorInfo info, object?resolvers, ResolveDelegate <BuilderContext>?pipeline)
{
var parameterResolvers = CreateParameterResolvers(info.GetParameters(), resolvers).ToArray();
return((ref BuilderContext context) =>
{
if (null == context.Existing)
{
var dependencies = new object[parameterResolvers.Length];
for (var i = 0; i < dependencies.Length; i++)
{
dependencies[i] = parameterResolvers[i](ref context);
}
context.Existing = info.Invoke(dependencies);
}
return null == pipeline ? context.Existing : pipeline.Invoke(ref context);
});
}
protected override ResolveDelegate <PipelineContext> GetResolverDelegate(ConstructorInfo info, object?resolvers,
ResolveDelegate <PipelineContext>?pipeline,
bool perResolve)
{
try
{
// Create parameter resolvers
var parameterResolvers = ParameterResolvers(info.GetParameters(), resolvers).ToArray();
// Select Lifetime type ( Per Resolve )
if (perResolve)
{
// Activate type
return((ref PipelineContext context) =>
{
if (null == context.Existing)
{
try
{
var dependencies = new object[parameterResolvers.Length];
for (var i = 0; i < dependencies.Length; i++)
{
dependencies[i] = parameterResolvers[i](ref context);
}
context.Existing = info.Invoke(dependencies);
context.Set(typeof(LifetimeManager), new RuntimePerResolveLifetimeManager(context.Existing));
}
catch (Exception ex)
{
ex.Data.Add(Guid.NewGuid(), info);
throw;
}
}
// Invoke other initializers
return null == pipeline ? context.Existing : pipeline.Invoke(ref context);
});
}
else
{
// Activate type
return((ref PipelineContext context) =>
{
if (null == context.Existing)
{
try
{
var dependencies = new object[parameterResolvers.Length];
for (var i = 0; i < dependencies.Length; i++)
{
dependencies[i] = parameterResolvers[i](ref context);
}
context.Existing = info.Invoke(dependencies);
}
catch (Exception ex)
{
ex.Data.Add(Guid.NewGuid(), info);
throw;
}
}
// Invoke other initializers
return null == pipeline ? context.Existing : pipeline.Invoke(ref context);
});
}
}
catch (InvalidRegistrationException ex)
{
// Throw if try to create
return((ref PipelineContext context) =>
{
if (null == context.Existing)
{
throw ex;
}
return null == pipeline ? context.Existing : pipeline.Invoke(ref context);
});
}
catch (Exception ex)
{
// Throw if try to create
return((ref PipelineContext context) =>
{
if (null == context.Existing)
{
throw new InvalidRegistrationException(ex);
}
return null == pipeline ? context.Existing : pipeline.Invoke(ref context);
});
}
}