public override void Inject(Object target, string objectName, IPropertyValues pvs)
{
MethodInfo method = _member as MethodInfo;
try
{
Object[] arguments;
if (_cached)
{
arguments = ResolveCachedArguments(objectName);
}
else
{
Type[] paramTypes = method.GetParameters().Select(p => p.ParameterType).ToArray();
arguments = new Object[paramTypes.Length];
var descriptors = new DependencyDescriptor[paramTypes.Length];
IList autowiredBeanNames = new ArrayList();
for (int i = 0; i < arguments.Length; i++)
{
MethodParameter methodParam = new MethodParameter(method, i);
descriptors[i] = new DependencyDescriptor(methodParam, _required);
arguments[i] = _objectFactory.ResolveDependency(descriptors[i], objectName,
autowiredBeanNames);
if (arguments[i] == null && !_required)
{
arguments = null;
break;
}
}
lock (this)
{
if (!_cached)
{
if (arguments != null)
{
_cachedMethodArguments = new Object[arguments.Length];
for (int i = 0; i < arguments.Length; i++)
{
_cachedMethodArguments[i] = descriptors[i];
}
RegisterDependentObjects(objectName, autowiredBeanNames);
if (autowiredBeanNames.Count == paramTypes.Length)
{
for (int i = 0; i < paramTypes.Length; i++)
{
string autowiredBeanName = autowiredBeanNames[i] as string;
if (_objectFactory.ContainsObject(autowiredBeanName))
{
if (_objectFactory.IsTypeMatch(autowiredBeanName, paramTypes[i]))
{
_cachedMethodArguments[i] =
new RuntimeObjectReference(autowiredBeanName);
}
}
}
}
}
else
{
_cachedMethodArguments = null;
}
_cached = true;
}
}
}
if (arguments != null)
{
method.Invoke(target, arguments);
}
}
catch (Exception ex)
{
throw new ObjectCreationException("Could not autowire method: " + method, ex);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DependencyDescriptor"/> class for a method or a constructor parameter.
/// </summary>
/// <param name="methodParameter">The MethodParameter to wrap.</param>
/// <param name="required">if set to <c>true</c> the dependency is required.</param>
/// <param name="eager">if set to <c>true</c> the dependency is 'eager' in the sense of
/// eagerly resolving potential target objects for type matching.</param>
public DependencyDescriptor(MethodParameter methodParameter, bool required, bool eager)
{
this.methodParameter = methodParameter;
this.required = required;
this.eager = eager;
}
private object ResolveAutoWiredArgument(MethodParameter methodParameter, string objectName, IList autowiredObjectNames)
{
return
this.autowireFactory.ResolveDependency(new DependencyDescriptor(methodParameter, true), objectName,
autowiredObjectNames);
}
/// <summary>
/// Initializes a new instance of the <see cref="DependencyDescriptor"/> class for a method or constructor parameter.
/// Considers the dependency as 'eager'
/// </summary>
/// <param name="methodParameter">The MethodParameter to wrap.</param>
/// <param name="required">if set to <c>true</c> if the dependency is required.</param>
public DependencyDescriptor(MethodParameter methodParameter, bool required)
: this(methodParameter, required, true)
{
}
