MethodReference ImportGenericInstanceMethod (SR.MethodInfo mi, ImportContext context)
{
SR.MethodInfo gmd = (SR.MethodInfo) mi.GetType ().GetMethod ("GetGenericMethodDefinition").Invoke (mi, null);
GenericInstanceMethod gim = new GenericInstanceMethod (
ImportMethodBase (gmd, gmd.ReturnType, context));
foreach (Type genArg in GetGenericArguments (mi))
gim.GenericArguments.Add (ImportSystemType (genArg, context));
return gim;
}
static int GetMetadataToken (SR.MethodInfo mi)
{
return (int) mi.GetType ().GetProperty ("MetadataToken").GetValue (mi, null);
}
private InjecteeCollection GetInjectees(SR.Assembly targetAssembly, SR.Assembly injectionAssembly)
{
_classInjectees = new List<TypeInjecteeBase>();
var injectees = new InjecteeCollection();
var injectionAssemblyTypes = injectionAssembly.GetTypes();
foreach (var injectionType in injectionAssemblyTypes)
{
var classAttrs = injectionType.GetCustomAttributes(typeof(InjectionAttributeBase), false);
if (classAttrs.Count(a => a != null) >= 2)
throw new InvalidOperationException("Can not define multiple class attributes for the same class");
var classAttr = classAttrs.Select(a => a as ITypeAttribute).FirstOrDefault(a => a != null);
if (classAttr == null)
continue;
if (classAttr is TypeAddInjectionAttribute)
{
var classAddInjectee = (TypeAddInjectee)classAttr.GetInjectee(null, injectionType);
if (!String.IsNullOrEmpty(classAddInjectee.Attr.ParentFullName))
classAddInjectee.ParentType = targetAssembly.GetType(classAddInjectee.Attr.ParentFullName, true);
injectees.Add(classAddInjectee);
_classInjectees.Add(classAddInjectee);
}
else
{
var name = !String.IsNullOrEmpty(classAttr.FullName) ? classAttr.FullName : injectionType.GetNormalizedName();
var targetType = targetAssembly.GetType(name, true);
var baseClassInjectee = classAttr.GetInjectee(targetType, injectionType);
injectees.Add(baseClassInjectee);
_classInjectees.Add(baseClassInjectee);
}
}
foreach (var baseClassInjectee in _classInjectees)
{
var classInjectee = baseClassInjectee as TypeInjectee;
if (classInjectee != null)
{
foreach (var field in classInjectee.InjecteeType.GetFields(BINDING_FLAGS))
{
var fieldAttrs = field.GetCustomAttributes(typeof(InjectionAttributeBase), false);
if (fieldAttrs.Count(a => a != null) >= 2)
throw new InvalidOperationException("Can not define multiple field attributes for the same field");
var fieldAttr = fieldAttrs.Select(a => a as IFieldAttribute).FirstOrDefault(a => a != null);
if (fieldAttr == null)
continue;
var targetField = GetTargetField(fieldAttr, classInjectee.TargetType, field);
var fieldInjectee = fieldAttr.GetInjectee(targetField, field, classInjectee);
classInjectee.Injectees.Add(fieldInjectee);
}
foreach (var method in classInjectee.InjecteeType.GetMethods(BINDING_FLAGS))
{
var methodAttrs = method.GetCustomAttributes(typeof(InjectionAttributeBase), false);
if (methodAttrs.Count(a => a != null) >= 2)
throw new InvalidOperationException("Can not define multiple method attributes for the same method");
var methodAttr = methodAttrs.Select(a => a as IMethodAttribute).FirstOrDefault(a => a != null);
if (methodAttr == null)
continue;
var targetMethod = GetTargetMethod(methodAttr, classInjectee.TargetType, method);
var methodInjectee = methodAttr.GetInjectee(targetMethod, method, classInjectee);
classInjectee.Injectees.Add(methodInjectee);
}
}
}
return injectees;
}
static Type [] GetGenericArguments (SR.MethodInfo mi)
{
return (Type []) mi.GetType ().GetMethod ("GetGenericArguments").Invoke (mi, null);
}
private void MapCustomAttributes(SR.ICustomAttributeProvider provider, MC.ICustomAttributeProvider targetProvider)
{
var type = provider.GetType();
// System.Reflection.Module.GetCustomAttributesData() not implemented in mono <= 3.4.0
if (_is_running_mono && typeof(System.Reflection.Module).IsAssignableFrom(type)) return;
var method = type.GetMethod("GetCustomAttributesData");
if (method == null)
throw new NotSupportedException("No method GetCustomAttributesData for type " + provider.GetType().FullName);
var custom_attributes_data = (IList<CustomAttributeData>)method.Invoke(provider, new object[0]);
foreach (var custom_attribute_data in custom_attributes_data)
{
var custom_attribute = new CustomAttribute(CreateReference(custom_attribute_data.Constructor, null));
foreach (var argument in custom_attribute_data.ConstructorArguments)
{
custom_attribute.ConstructorArguments.Add(CustomAttributeArgumentFor(argument));
}
foreach (var named_argument in custom_attribute_data.NamedArguments)
{
var argument = new MC.CustomAttributeNamedArgument(named_argument.MemberInfo.Name, CustomAttributeArgumentFor(named_argument.TypedValue));
if (named_argument.MemberInfo is PropertyInfo)
custom_attribute.Properties.Add(argument);
else if (named_argument.MemberInfo is FieldInfo)
custom_attribute.Fields.Add(argument);
else
throw new NotSupportedException();
}
targetProvider.CustomAttributes.Add(custom_attribute);
}
}
