private static void OnComponentPreparing(object sender, PreparingEventArgs e)
{
var t = e.Component.Activator.LimitType;
e.Parameters =
e.Parameters.Union(new[] { new ResolvedParameter((p, i) => p.ParameterType == typeof(ILog), (p, i) => LogManager.GetLogger(t)) });
}
static void OnComponentPreparing(object sender, PreparingEventArgs e)
{
e.Parameters = e.Parameters.Append(
new ResolvedParameter(
(p, _) => p.ParameterType == typeof(ILogger),
(p, c) => c.Resolve(typeof(ILogger <>).MakeGenericType(p.Member.DeclaringType))));
}
private static void OnComponentPreparing(object sender, PreparingEventArgs e)
{
var limitType = e.Component.Activator.LimitType;
var loggerType = typeof(ILogger);
var loggerGenericType = typeof(ILogger <>);
e.Parameters = e.Parameters.Union(
new[]
{
new ResolvedParameter(
delegate(ParameterInfo info, IComponentContext context)
{
return(info.ParameterType == loggerType ||
info.ParameterType.IsGenericType && info.ParameterType.GetGenericTypeDefinition() == loggerGenericType);
}, delegate(ParameterInfo info, IComponentContext context)
{
if (info.ParameterType == loggerType)
{
return(GetLogger(context, limitType, info.ParameterType));
}
return(GetLogger(context, limitType, info.ParameterType));
})
//new ResolvedParameter((parameterInfo, context) =>
//parameterInfo.ParameterType == loggerType ||
//parameterInfo.ParameterType.IsGenericParameter && parameterInfo.ParameterType.GetGenericTypeDefinition() == loggerGenericType,
//(parameterInfo, context) => GetLogger(context, limitType, parameterInfo.ParameterType))
});
}
private static void ConfigureLoggerParameter(object sender, PreparingEventArgs e)
{
var type = e.Component.Activator.LimitType;
var param = new ResolvedParameter(ParameterPredicate, (i, c) => LoggerFactory.GetLogger(type.FullName));
e.Parameters = e.Parameters.Concat(new[] { param });
}
private static void OnComponentPreparing(object sender, PreparingEventArgs e)
{
var resolvedParameter = new ResolvedParameter((p, i) => p.ParameterType == typeof(IBashiLogger),
(p, i) => new BashiLogger(LogManager.GetLogger(p.Member.DeclaringType)));
e.Parameters = e.Parameters.Union(new[] { resolvedParameter });
}
private void Registration_Preparing(object sender, PreparingEventArgs e)
{
foreach (var param in e.Parameters)
{
Console.WriteLine(param.ToString());
}
}
private static void AddILoggerToParameters(object sender, PreparingEventArgs e)
{
var t = e.Component.Activator.LimitType;
var resolvedParameter = new ResolvedParameter((p, i) => p.ParameterType == typeof(ILogger), (p, i) => new SerilogWrapper(i.Resolve <Serilog.ILogger>().ForContext(t)));
e.Parameters = e.Parameters.Union(new[] { resolvedParameter });
}
static void OnComponentPreparing(object sender, PreparingEventArgs e)
{
e.Parameters = e.Parameters.Union(new[]
{
new ResolvedParameter((p, i) => p.ParameterType == typeof(ILogger), (p, i) => LogManager.GetCurrentClassLogger())
});
}
/// <summary>
/// Pass parameters from the top level resolve operation (typically a delegate factory call)
/// to a nested component activation.
/// </summary>
public static void ForwardFactoryParameters(PreparingEventArgs e)
{
var instanceLookup = (IInstanceLookup)e.Context;
var resolveOperation = (IResolveOperation)s_contextFieldInfo.GetValue(instanceLookup);
var activationStack = (IEnumerable <IInstanceLookup>)s_activationStackFieldInfo.GetValue(resolveOperation);
e.Parameters = e.Parameters.Concat(activationStack.Last().Parameters);
}
private void RegistrationOnPreparing(object sender, PreparingEventArgs preparingEventArgs)
{
if (Logger.IsEnabled(LogEventLevel.Verbose))
{
Logger.Verbose($"{GetPrefix()}Resolving {{Type}}", preparingEventArgs.Component.Activator.LimitType);
}
Depth++;
}
private void RegistrationOnPreparing(object sender, PreparingEventArgs preparingEventArgs)
{
Trace.Write(this.GetPrefix());
Trace.Write("Resolving ");
Trace.Write(preparingEventArgs.Component.Activator.LimitType);
Trace.WriteLine(string.Empty);
this.depth++;
}
/// <summary>
/// Called when [component preparing].
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="PreparingEventArgs"/> instance containing the event data.</param>
private static void OnComponentPreparing(object sender, PreparingEventArgs e)
{
e.Parameters = e.Parameters.Union(
new[]
{
new ResolvedParameter((p, i) => p.ParameterType == typeof(ILog), (p, i) => LogManager.GetLogger(p.Member.DeclaringType)),
});
}
private static void AddLoggerParameter(object sender, PreparingEventArgs e)
{
var logParameter = new ResolvedParameter(
(p, i) => p.ParameterType == typeof(ILogger),
(p, i) => LogManager.GetLogger(e.Component.Activator.LimitType.FullName));
e.Parameters = e.Parameters.Concat(new[] { logParameter });
}
/// <summary>
/// The inject logger via constructor.
/// </summary>
/// <param name="sender">
/// The sender.
/// </param>
/// <param name="event">
/// The event.
/// </param>
private void InjectLoggerViaConstructor(object sender, PreparingEventArgs @event)
{
var type = @event.Component.Activator.LimitType;
@event.Parameters = @event.Parameters.Union(new[]
{
new ResolvedParameter((parameter, context) => parameter.ParameterType == typeof(TLogger), (p, i) => this.CreateLoggerFor(type))
});
}
private void RegistrationOnPreparing(object sender, PreparingEventArgs preparingEventArgs)
{
if (Log.IsVerboseEnabled())
{
Log.Verbose().WriteLine("{0}Resolving {1}", GetPrefix(), preparingEventArgs.Component.Activator.LimitType);
}
_depth++;
}
private void OnComponentPreparing(object sender, PreparingEventArgs e) {
var t = e.Component.Descriptor.BestKnownImplementationType;
e.Parameters = e.Parameters.Union(new[] {
new ResolvedParameter((p, i) => p.ParameterType == typeof(ILog), (p, i) => {
var loggerRepository = i.Resolve<ILoggerRepository>();
return loggerRepository.Get(t);
})
});
}
public Node Link(PreparingEventArgs e, Node focus)
{
if (focus._chain != null)
{
TraceMessage("REACTIVATED: Preparing[{2}] {0} {1}", e.Component);
}
focus._chain = this;
return(focus);
}
private void InjectAppSettingParameters(object sender, PreparingEventArgs e)
{
// check if parameter is of type AppSetting and if it is return AppSetting using the parameter name
var appSettingParameter = new ResolvedParameter((par, ctx) => par.ParameterType == typeof(AppSetting), (par, ctx) => new AppSetting(ConfigurationManager.AppSettings[par.Name]));
e.Parameters = e.Parameters.Union(new List <Parameter> {
appSettingParameter
});
}
static void OnComponentPreparing(object sender, PreparingEventArgs e)
{
var t = e.Component.Activator.LimitType;
e.Parameters = e.Parameters.Union(new[]
{
new ResolvedParameter((p, i) => p.ParameterType == typeof(TParameterType), (p, i) => _componentFactory(t))
});
}
private void OnComponentPreparing(object sender, PreparingEventArgs e)
{
e.Parameters = e.Parameters.Concat(new[] {
new ResolvedParameter(
(pi, ctx) => _filter(pi),
(pi, ctx) => _factory(pi, ctx)
)
});
}
private void Registration_Preparing(object sender, PreparingEventArgs args)
{
var forType = args.Component.Activator.LimitType;
var logParameter = new ResolvedParameter(
(p, c) => p.ParameterType == typeof(ILogger),
(p, c) => c.Resolve <ILogger>(TypedParameter.From(forType)));
args.Parameters = args.Parameters.Union(new[] { logParameter });
}
private void OnComponentPreparing(object sender, PreparingEventArgs e)
{
var t = e.Component.Activator.LimitType;
e.Parameters = e.Parameters.Union(
new[]
{
new ResolvedParameter((p, i) => p.ParameterType == typeof(ILogger), (p, i) => _loggerFactory.CreateLogger(t))
});
}
private static void PrepareLogger(object sender, PreparingEventArgs e)
{
e.Parameters = e.Parameters.Union(new[]
{
new ResolvedParameter(
(p, c) => p.ParameterType == typeof(NLog.ILogger),
(p, c) => NLog.LogManager.GetLogger(p.Member.DeclaringType?.FullName)
)
});
}
private static void AddILoggerToParameters(object sender, PreparingEventArgs e)
{
var t = e.Component.Activator.LimitType;
e.Parameters = e.Parameters.Union(
new[]
{
new ResolvedParameter((p, i) => p.ParameterType == typeof(ILogger), (p, i) => i.Resolve <ILogger>().ForContext(t))
});
}
/// <summary>
/// Adds into every component's registration
/// a property that resolves to the logger for that type
/// See http://docs.autofac.org/en/latest/examples/log4net.html
/// </summary>
void registration_Preparing(object sender, PreparingEventArgs e)
{
e.Parameters = e.Parameters
.Concat(new[] {
new ResolvedParameter(
(p, context) => p.ParameterType == typeof(TLogger),
(p, context) => _logFactory(p.Member.DeclaringType)
)
});
}
private void InjectSettings(object sender, PreparingEventArgs e)
{
e.Parameters = e.Parameters.Union(new[]
{
new ResolvedParameter(
(info, context) =>
info.ParameterType.IsGenericType && info.ParameterType.GetGenericTypeDefinition() == typeof(ISetting <>),
(parameterInfo, context) =>
context.ResolveNamed(parameterInfo.Name.ToLower(), parameterInfo.ParameterType))
});
}
private static void OnComponentPreparing(object sender, PreparingEventArgs e)
{
var t = e.Component.Activator.LimitType;
e.Parameters = e.Parameters.Union(
new[]
{
new ResolvedParameter((p, i) => p.ParameterType == typeof(ILogger),
(p, i) => new NLogFilteredLogger(t.FullName))
});
}
private void OnComponentPreparing(object sender, PreparingEventArgs e)
{
var t = e.Component.Descriptor.BestKnownImplementationType;
e.Parameters = e.Parameters.Union(new[] {
new ResolvedParameter((p, i) => p.ParameterType == typeof(ILog), (p, i) => {
var loggerRepository = i.Resolve <ILoggerRepository>();
return(loggerRepository.Get(t));
})
});
}
private void OnComponentPreparing(object sender, PreparingEventArgs e)
{
e.Parameters = e.Parameters.Union(
new[]
{
new ResolvedParameter(
(p, i) => p.ParameterType == typeof(ILog),
(p, i) => new ILogTraceWriterAdapter(p.Member.DeclaringType, e.Context.Resolve <TraceWriter>())
),
});
}
public event EventHandler <PreparingEventArgs> Preparing; // = (s, e) => { };
/// <summary>
/// Called by the container when an instance is required.
/// </summary>
/// <param name="service">Service which is preparing</param>
/// <param name="context">The context in which the instance will be activated.</param>
/// <param name="parameters">Parameters for activation.</param>
public void RaisePreparing(Service service, IComponentContext context, ref IEnumerable <Parameter> parameters)
{
var ev = Preparing;
if (ev != null)
{
var args = new PreparingEventArgs(service, context, this, parameters);
ev(this, args);
parameters = args.Parameters;
}
}
private void RegistrationOnPreparing(object sender, PreparingEventArgs e)
{
var limitType = e.Component.Activator.LimitType;
e.Parameters = e.Parameters.Union(new[]
{
new ResolvedParameter(
(pi, c) => pi.ParameterType == typeof(ILogger),
(pi, c) => RadarrLogger.GetLogger(limitType))
});
}
/// <summary>
/// Called by the container when an instance is required.
/// </summary>
/// <param name="context">The context in which the instance will be activated.</param>
/// <param name="parameters">Parameters for activation.</param>
public void RaisePreparing(IComponentContext context, ref IEnumerable<Parameter> parameters)
{
var handler = Preparing;
if (handler == null) return;
var args = new PreparingEventArgs(context, this, parameters);
handler(this, args);
parameters = args.Parameters;
}
public event EventHandler<PreparingEventArgs> Preparing;// = (s, e) => { };
/// <summary>
/// Called by the container when an instance is required.
/// </summary>
/// <param name="service">Service which is preparing</param>
/// <param name="context">The context in which the instance will be activated.</param>
/// <param name="parameters">Parameters for activation.</param>
public void RaisePreparing(Service service, IComponentContext context, ref IEnumerable<Parameter> parameters)
{
var ev = Preparing;
if (ev != null)
{
var args = new PreparingEventArgs(service, context, this, parameters);
ev(this, args);
parameters = args.Parameters;
}
}
