public void AddBuilderMember(Type targetType, List <IBuilderMember> members)
{
var field = targetType.GetField(fieldName);
//var field = targetType.GetField(fieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.SetField| BindingFlags.CreateInstance| BindingFlags.Static| BindingFlags.GetField);
if (field == null)
{
throw new InjectionException(string.Format("type <{0}> not found field <{1}>", targetType.FullName, fieldName));
}
if (field.IsInitOnly)
{
throw new InjectionException(string.Format("type <{0}> field <{1}> is can't write", targetType.FullName, fieldName));
}
BuilderParameterInfo paramInfo;
if (hasValue)
{
paramInfo = BuilderParameterInfo.MakeValue(field.FieldType, null, value);
}
else
{
paramInfo = InjectorUtils.FromAttributeProvider(field, field.FieldType);
}
members.Add(new FieldBuilder(field, paramInfo));
}
public void AddBuilderMember(Type targetType, List <IBuilderMember> members)
{
var eventInfo = targetType.GetEvent(eventName);
if (eventInfo == null)
{
throw new InjectionException(string.Format("type <{0}> not found event <{1}>", targetType.FullName, eventName));
}
if (eventInfo.GetAddMethod(true) == null)
{
throw new InjectionException(string.Format("type <{0}> event <{1}> can't add", targetType.FullName, eventName));
}
BuilderParameterInfo paramInfo;
if (hasValue)
{
paramInfo = BuilderParameterInfo.MakeValue(eventInfo.EventHandlerType, null, value);
}
else
{
paramInfo = InjectorUtils.FromAttributeProvider(eventInfo, eventInfo.EventHandlerType);
}
members.Add(new EventBuilder(eventInfo, paramInfo));
}
public void AddBuilderMember(Type targetType, List <IBuilderMember> members)
{
var property = targetType.GetProperty(propertyName);
if (property == null)
{
throw new InjectionException(string.Format("type <{0}> not found property <{1}>", targetType.FullName, propertyName));
}
if (!property.CanWrite)
{
throw new InjectionException(string.Format("type <{0}> property <{1}> can't write", targetType.FullName, propertyName));
}
BuilderParameterInfo paramInfo;
if (hasValue)
{
paramInfo = BuilderParameterInfo.MakeValue(property.PropertyType, null, value);
}
else
{
paramInfo = InjectorUtils.FromAttributeProvider(property, property.PropertyType);
}
members.Add(new PropertyBuilder(property, paramInfo));
}
public void AddBuilderMember(Type targetType, List <IBuilderMember> members)
{
BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.InvokeMethod;
var injectParams = BuilderParameterInfo.FromArgs(args);
var methodBase = InjectorUtils.FindMethod(targetType, methodName, args, bindingFlags);
if (methodBase == null)
{
throw new InjectionException(string.Format("type <{0}> not found method <{1}>", targetType, methodName));
}
members.Add(new MethodBuilder(methodBase, injectParams));
}
public static BuilderParameterInfo[] FromMethod(MethodBase methodBase)
{
ParameterInfo[] parameters = methodBase.GetParameters();
if (parameters.Length > 0)
{
BuilderParameterInfo[] injectParams = new BuilderParameterInfo[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
var p = parameters[i];
var injectParam = FromAttributeProvider(p, p.ParameterType);
injectParams[i] = injectParam;
}
return(injectParams);
}
return(BuilderParameterInfo.EmptyArray);
}
internal static object GetValue(this IInjector source, BuilderParameterInfo parameterInfo, IEnumerable <IBuilderValue> values)
{
if (parameterInfo == null)
{
throw new ArgumentNullException(nameof(parameterInfo));
}
if (parameterInfo.HasValue)
{
return(parameterInfo.Value);
}
Type valueType = parameterInfo.ParameterType;
string name = parameterInfo.Name;
if (values != null)
{
foreach (var item in values)
{
if (item.IsMatchValue(valueType, name))
{
return(item.GetValue(valueType, name));
}
}
}
if (valueType != null)
{
object value;
if (source.TryGetValue(valueType, name, out value))
{
return(value);
}
if (source.IsTypeRegistered(valueType, name))
{
return(source.CreateInstance(valueType, name, values.ToArray()));
}
}
if (parameterInfo.HasDefaultValue)
{
return(parameterInfo.DefaultValue);
}
throw new BuilderValueNotFoundException(valueType, name);
}
internal static BuilderParameterInfo FromAttributeProvider(ICustomAttributeProvider provider, Type defaultType, string defaultName = null)
{
var valueAttr = provider.GetCustomAttribute <InjectValueAttribute>(true);
var defaultAttr = provider.GetCustomAttribute <DefaultValueAttribute>(true);
Type type = null;
string name = null;
bool hasDefaultValue = false;
object defaultValue = null;
if (valueAttr != null)
{
type = valueAttr.Type;
name = valueAttr.Name;
}
if (defaultAttr != null)
{
defaultValue = defaultAttr.DefaultValue;
hasDefaultValue = true;
}
if (type == null)
{
type = defaultType;
}
if (string.IsNullOrEmpty(name))
{
name = defaultName;
}
BuilderParameterInfo p;
if (hasDefaultValue)
{
p = BuilderParameterInfo.MakeDefault(type, name, defaultValue);
}
else
{
p = new BuilderParameterInfo(type, name);
}
return(p);
}
public object GetValue(BuilderParameterInfo parameterInfo, IBuilderValue[] values)
{
return(injector.GetValue(parameterInfo, CombinValues(values, this.values)));
}
public InjectConstructor(params Type[] argTypes)
: this(BuilderParameterInfo.FromTypes(argTypes))
{
}
public InjectConstructor(params object[] args)
: this(BuilderParameterInfo.FromArgs(args))
{
}
