public InterfaceImplementationWeaver(ConstructorWeaver constructorWeaver, MethodWeaver methodWeaver)
{
this.constructorWeaver = constructorWeaver;
this.methodWeaver = methodWeaver;
this.objectTypeReference = WeavingInformation.ReferenceFinder.GetTypeReference(typeof(object));
this.objectConstructorReference = WeavingInformation.ReferenceFinder.GetMethodReference(this.objectTypeReference, x => x.IsConstructor);
}
/// <summary>
/// Transforms the methods in the <paramref name="target"/> using the given method rewriter.
/// </summary>
/// <param name="target">The transformation target.</param>
/// <param name="rewriter">The method rewriter.</param>
/// <param name="filter">The method filter that determines which methods will be rewritten.</param>
public static void WeaveWith(this IReflectionVisitable target, IMethodRewriter rewriter,
Func <MethodReference, bool> filter)
{
var weaver = new MethodWeaver(rewriter, filter);
target.Accept(weaver);
}
public override void Execute()
{
var configOptions = new WeaverConfigOptions(Config);
var config = new WeaverConfig(configOptions, ModuleDefinition);
var context = new ModuleWeavingContext(ModuleDefinition, config);
foreach (var type in ModuleDefinition.GetTypes())
{
foreach (var method in type.Methods)
{
try
{
if (!MethodWeaver.NeedsProcessing(context, method))
{
continue;
}
_log.Debug($"Processing: {method.FullName}");
new MethodWeaver(context, method).Process();
}
catch (WeavingException ex)
{
AddError(ex.Message, ex.SequencePoint);
InvalidateMethod(method, ex.Message);
}
}
if (type.IsInlineILTypeUsageDeep(context))
{
AddError($"Reference to InlineIL found in type {type.FullName}. InlineIL should not be referenced in attributes/constraints, as its assembly reference will be removed.", null);
}
}
RemoveLibReference(context);
}
public TraceInjector(IWeaveParameters parameters)
: base(parameters)
{
exceptionWeaver = new ExceptionTraceWeaver();
exceptionWeaver.Parameters = this.Parameters;
itemTraceWeaver = new ItemTraceWeaver();
itemTraceWeaver.Parameters = this.Parameters;
}
public static void Execute()
{
IEnumerable <TypeDefinition> typesToProxy = WeavingInformation.ModuleDefinition.Types
.Where(HasStaticProxyAttribute)
.ToList();
var constructorWeaver = new ConstructorWeaver();
var methodWeaver = new MethodWeaver();
var interfaceImplementationWeaver = new InterfaceImplementationWeaver(constructorWeaver, methodWeaver);
var classDecorationWeaver = new ClassDecorationWeaver(constructorWeaver, methodWeaver);
ImplementInterfaces(
typesToProxy.Where(x => x.IsInterface),
interfaceImplementationWeaver);
DecorateClasses(classDecorationWeaver, typesToProxy.Where(x => x.IsClass).ToList());
}
public ClassDecorationWeaver(ConstructorWeaver constructorWeaver, MethodWeaver methodWeaver)
{
this.constructorWeaver = constructorWeaver;
this.methodWeaver = methodWeaver;
}
/// <summary>
/// Transforms the methods in the <paramref name="target"/> using the given method rewriter.
/// </summary>
/// <param name="target">The transformation target.</param>
/// <param name="rewriter">The method rewriter.</param>
/// <param name="filter">The method filter that determines which methods will be rewritten.</param>
public static void WeaveWith(this IReflectionVisitable target, IMethodRewriter rewriter,
Func<MethodReference, bool> filter)
{
var weaver = new MethodWeaver(rewriter, filter);
target.Accept(weaver);
}
