public static CustomAttribute InjectCustomAttribute(this ICustomAttributeProvider provider, CustomAttribute attribute, ReferenceResolver resolver)
{
if (attribute == null)
throw new ArgumentNullException("attribute");
if (resolver == null)
throw new ArgumentNullException("resolver");
TypeReference attributeType = resolver.ReferenceType(attribute.AttributeType);
// no context required as attributes cannot be generic
MethodReference constructor = resolver.ReferenceMethod(attribute.Constructor);
CustomAttribute newAttribute;
if ((newAttribute = Helper.GetCustomAttribute(provider.CustomAttributes, attribute)) != null)
return newAttribute;
newAttribute = new CustomAttribute(constructor);//, attr.GetBlob());
provider.CustomAttributes.Add(newAttribute);
MetadataBuilderHelper.CopyCustomAttributeArguments(attribute.ConstructorArguments, newAttribute.ConstructorArguments, resolver);
MetadataBuilderHelper.CopyCustomAttributeNamedArguments(attribute.Fields, newAttribute.Fields, resolver);
MetadataBuilderHelper.CopyCustomAttributeNamedArguments(attribute.Properties, newAttribute.Properties, resolver);
return newAttribute;
}
public static FieldDefinition InjectField(this TypeDefinition targetType, FieldDefinition sourceField, ReferenceResolver resolver)
{
if (sourceField == null)
throw new ArgumentNullException("sourceField");
if (resolver == null)
throw new ArgumentNullException("resolver");
FieldDefinition newField = null;
if (Helper.TryGetField(targetType.Fields, sourceField, ref newField))
return newField;
TypeReference fieldType = resolver.ReferenceType(sourceField.FieldType, targetType);
newField = new FieldDefinition(sourceField.Name, sourceField.Attributes, fieldType)
{
InitialValue = sourceField.InitialValue,
DeclaringType = targetType,
};
targetType.Fields.Add(newField);
MetadataBuilderHelper.CopyCustomAttributes(sourceField, newField, resolver);
if (newField.HasDefault)
newField.Constant = sourceField.Constant;
return newField;
}
public static void CopyCustomAttributeArguments(Collection<Mono.Cecil.CustomAttributeArgument> source, Collection<Mono.Cecil.CustomAttributeArgument> target, ReferenceResolver resolver)
{
foreach (var argument in source)
{
var argumentType = resolver.ReferenceType(argument.Type);
target.Add(new CustomAttributeArgument(argumentType, argument.Value));
}
}
public static void InjectSecurityAttribute(this SecurityDeclaration target, SecurityAttribute attribute, ReferenceResolver resolver)
{
var attributeType = resolver.ReferenceType(attribute.AttributeType);
var newAttribute = new SecurityAttribute(attributeType);
MetadataBuilderHelper.CopyCustomAttributeNamedArguments(attribute.Fields, newAttribute.Fields, resolver);
MetadataBuilderHelper.CopyCustomAttributeNamedArguments(attribute.Properties, newAttribute.Properties, resolver);
target.SecurityAttributes.Add(newAttribute);
}
public static void InjectGenericParameter(this IGenericParameterProvider owner, GenericParameter parameter, ReferenceResolver resolver)
{
GenericParameter newParameter = new GenericParameter(parameter.Name, owner)
{
Attributes = parameter.Attributes
};
owner.GenericParameters.Add(newParameter);
MetadataBuilderHelper.CopyCustomAttributes(newParameter, parameter, resolver);
foreach (var constraint in parameter.Constraints)
{
if (owner is MethodReference)
newParameter.Constraints.Add(resolver.ReferenceType(constraint, owner, ((MethodReference)owner).DeclaringType));
else
newParameter.Constraints.Add(resolver.ReferenceType(constraint, owner));
}
}
public static TypeDefinition CreateNewType(TypeDefinition sourceType, ReferenceResolver resolver)
{
TypeDefinition newType = new TypeDefinition(sourceType.Namespace, sourceType.Name, sourceType.Attributes)
{
PackingSize = sourceType.PackingSize,
ClassSize = sourceType.ClassSize,
};
CopyGenericParameters(sourceType, newType, resolver);
if (sourceType.BaseType != null)
{
newType.BaseType = resolver.ReferenceType(sourceType.BaseType, newType);
}
CopyCustomAttributes(sourceType, newType, resolver);
return newType;
}
public static EventDefinition InjectEvent(this TypeDefinition targetType, EventDefinition sourceEvent, ReferenceResolver resolver)
{
if (sourceEvent == null)
throw new ArgumentNullException("sourceEvent");
if (resolver == null)
throw new ArgumentNullException("resolver");
var eventType = resolver.ReferenceType(sourceEvent.EventType, targetType);
EventDefinition newEvent = null;
if (Helper.TryGetEvent(targetType.Events, sourceEvent, ref newEvent))
return newEvent;
newEvent = new EventDefinition(sourceEvent.Name, sourceEvent.Attributes, eventType)
{
DeclaringType = targetType,
};
targetType.Events.Add(newEvent);
MetadataBuilderHelper.CopyCustomAttributes(sourceEvent, newEvent, resolver);
if (sourceEvent.AddMethod != null)
{
newEvent.AddMethod = targetType.InjectMethod(sourceEvent.AddMethod, resolver);
}
if (sourceEvent.RemoveMethod != null)
{
newEvent.RemoveMethod = targetType.InjectMethod(sourceEvent.RemoveMethod, resolver);
}
foreach (var otherMethod in sourceEvent.OtherMethods)
{
newEvent.OtherMethods.Add(targetType.InjectMethod(otherMethod, resolver));
}
return newEvent;
}
public static MethodDefinition InjectMethod(this TypeDefinition targetType, MethodDefinition sourceMethod, ReferenceResolver resolver, bool body = true)
{
if (sourceMethod == null)
throw new ArgumentNullException("sourceMethod");
if (resolver == null)
throw new ArgumentNullException("resolver");
// Console.WriteLine("\tCreating method {0}", sourceMethod.FullName);
MethodDefinition newMethod = null;
if (Helper.TryGetMethod(targetType.Methods, sourceMethod, ref newMethod))
return newMethod;
newMethod = new MethodDefinition(sourceMethod.Name, sourceMethod.Attributes, sourceMethod.ReturnType)
{
ExplicitThis = sourceMethod.ExplicitThis,
ImplAttributes = sourceMethod.ImplAttributes,
SemanticsAttributes = sourceMethod.SemanticsAttributes,
DeclaringType = targetType,
CallingConvention = sourceMethod.CallingConvention,
};
targetType.Methods.Add(newMethod);
MetadataBuilderHelper.CopyGenericParameters(sourceMethod, newMethod, resolver);
CopyParameters(sourceMethod, newMethod, resolver);
newMethod.ReturnType = resolver.ReferenceType(sourceMethod.ReturnType, newMethod, targetType);
MetadataBuilderHelper.CopyCustomAttributes(sourceMethod, newMethod, resolver);
CopyOverrides(sourceMethod, newMethod, resolver);
MetadataBuilderHelper.CopySecurityDeclarations(sourceMethod, newMethod, resolver);
if(body)
CopyMethodBody(sourceMethod, newMethod, resolver);
// Console.WriteLine("\tCreated method {0}", sourceMethod.FullName);
return newMethod;
}
private static void CopyVariables(MethodDefinition sourceMethod, MethodDefinition targetMethod, ReferenceResolver resolver)
{
if (!sourceMethod.Body.HasVariables)
return;
foreach (var variableDefinition in sourceMethod.Body.Variables)
{
var variableType = resolver.ReferenceType(variableDefinition.VariableType, targetMethod, targetMethod.DeclaringType);
VariableDefinition newVariable = new VariableDefinition(variableDefinition.Name, variableType);
targetMethod.Body.Variables.Add(newVariable);
}
}
private static void CopyParameters(MethodReference sourceMethod, MethodReference targetMethod, ReferenceResolver resolver)
{
if (!sourceMethod.HasParameters)
return;
//to have full method signature when determining generic patameter owner
foreach (var parameterDefinition in sourceMethod.Parameters)
targetMethod.Parameters.Add(parameterDefinition);
//fix references
for (int i = 0; i < targetMethod.Parameters.Count; i++)
{
var parameterDefinition = targetMethod.Parameters[i];
var parameterType = resolver.ReferenceType(parameterDefinition.ParameterType, targetMethod, targetMethod.DeclaringType);
ParameterDefinition newParameter = new ParameterDefinition(parameterDefinition.Name, parameterDefinition.Attributes, parameterType)
{
HasConstant = parameterDefinition.HasConstant,
MarshalInfo = parameterDefinition.MarshalInfo,
};
targetMethod.Parameters[i] = newParameter;
if (parameterDefinition.HasDefault)
newParameter.Constant = parameterDefinition.Constant;
MetadataBuilderHelper.CopyCustomAttributes(parameterDefinition, newParameter, resolver);
}
}
private static void CopyInstructions(MethodDefinition sourceMethod, MethodDefinition targetMethod, ReferenceResolver resolver)
{
TypeDefinition targetType = targetMethod.DeclaringType;
var processor = targetMethod.Body.GetILProcessor();
var offset = 0;
foreach (var instruction in sourceMethod.Body.Instructions)
{
object operand;
if (instruction.Operand is FieldReference)
{
operand = resolver.ReferenceField((FieldReference)instruction.Operand, targetMethod, targetType);
}
else if (instruction.Operand is MethodReference)
{
operand = resolver.ReferenceMethod((MethodReference)instruction.Operand, targetMethod, targetType);
}
else if (instruction.Operand is TypeReference)
{
operand = resolver.ReferenceType((TypeReference)instruction.Operand, targetMethod, targetType);
}
else
{
operand = instruction.Operand;
}
Instruction newInstruction = Helper.CreateInstruction(instruction.OpCode, instruction.OpCode.OperandType, operand);
newInstruction.SequencePoint = instruction.SequencePoint;
newInstruction.Offset = offset;
offset += newInstruction.GetSize();
processor.Append(newInstruction);
}
FixBranchingTargets(targetMethod.Body);
CopyExceptionHandlers(sourceMethod, targetMethod, resolver);
}
private static void CopyExceptionHandlers(MethodDefinition sourceMethod, MethodDefinition targetMethod, ReferenceResolver resolver)
{
if (!sourceMethod.Body.HasExceptionHandlers)
return;
foreach (var handler in sourceMethod.Body.ExceptionHandlers)
{
var newHandler = new ExceptionHandler(handler.HandlerType)
{
FilterStart = GetInstruction(targetMethod.Body, handler.FilterStart),
// FilterEnd = GetInstruction(targetMethod.Body, handler.FilterEnd),
HandlerStart = GetInstruction(targetMethod.Body, handler.HandlerStart),
HandlerEnd = GetInstruction(targetMethod.Body, handler.HandlerEnd),
TryStart = GetInstruction(targetMethod.Body, handler.TryStart),
TryEnd = GetInstruction(targetMethod.Body, handler.TryEnd),
};
if (handler.CatchType != null)
newHandler.CatchType = resolver.ReferenceType(handler.CatchType, targetMethod, targetMethod.DeclaringType);
targetMethod.Body.ExceptionHandlers.Add(newHandler);
}
}
public static TypeDefinition InjectTypeMembers(this TypeDefinition type, TypeDefinition sourceType, ReferenceResolver resolver)
{
if (sourceType == null)
throw new ArgumentNullException("sourceType");
if (resolver == null)
throw new ArgumentNullException("resolver");
foreach (var nestedType in sourceType.NestedTypes)
type.InjectNestedType(nestedType, resolver);
foreach (var @interface in sourceType.Interfaces)
type.Interfaces.Add(resolver.ReferenceType(@interface, type));
foreach (var field in sourceType.Fields)
type.InjectField(field, resolver);
foreach (var @event in sourceType.Events)
type.InjectEvent(@event, resolver);
foreach (var method in sourceType.Methods)
type.InjectMethod(method, resolver);
foreach (var property in sourceType.Properties)
type.InjectProperty(property, resolver);
MetadataBuilderHelper.CopySecurityDeclarations(sourceType, type, resolver);
Console.WriteLine("Created type {0}", type.FullName);
return type;
}
public static PropertyDefinition InjectProperty(this TypeDefinition targetType, PropertyDefinition sourceProperty, ReferenceResolver resolver)
{
if (sourceProperty == null)
throw new ArgumentNullException("sourceProperty");
if (resolver == null)
throw new ArgumentNullException("resolver");
TypeReference propertyType = resolver.ReferenceType(sourceProperty.PropertyType, targetType);
PropertyDefinition newProperty = null;
if (Helper.TryGetProperty(targetType.Properties, sourceProperty, ref newProperty))
return newProperty;
newProperty = new PropertyDefinition(sourceProperty.Name, sourceProperty.Attributes, propertyType)
{
DeclaringType = targetType
};
targetType.Properties.Add(newProperty);
MetadataBuilderHelper.CopyCustomAttributes(sourceProperty, newProperty, resolver);
if (sourceProperty.GetMethod != null)
{
newProperty.GetMethod = targetType.InjectMethod(sourceProperty.GetMethod, resolver);
}
if (sourceProperty.SetMethod != null)
{
newProperty.SetMethod = targetType.InjectMethod(sourceProperty.SetMethod, resolver);
}
return newProperty;
}
