public void Execute()
{
this.LogInfo = s => { };
this.LogWarning = s => { };
var decorator = new MethodDecorator.Fody.MethodDecorator(this.ModuleDefinition, Config);
foreach (var x in this.ModuleDefinition.AssemblyReferences)
{
AssemblyResolver.Resolve(x);
}
this.DecorateDirectlyAttributed(decorator);
this.DecorateAttributedByImplication(decorator);
if (this.ModuleDefinition.AssemblyReferences.Count(r => r.Name == "mscorlib") > 1)
{
throw new Exception(
String.Format(
"Error occured during IL weaving. The new assembly is now referencing more than one version of mscorlib: {0}",
String.Join(", ", this.ModuleDefinition.AssemblyReferences.Where(r => r.Name == "mscorlib").Select(r => r.FullName))
)
);
}
}
private void DecorateByType(MethodDecorator.Fody.MethodDecorator decorator)
{
var referenceFinder = new ReferenceFinder(this.ModuleDefinition);
var markerTypeDefinitions = this.FindMarkerTypes();
// Look for rules in the assembly and module.
var assemblyRules = FindAspectRules(this.ModuleDefinition.Assembly.CustomAttributes);
var moduleRules = FindAspectRules(this.ModuleDefinition.CustomAttributes);
// Read the top-level and nested types from this module
foreach (var type in this.ModuleDefinition.Types.SelectMany(x => GetAllTypes(x)))
{
// Look for rules on the type and marker attributes
var classRules = FindByMarkerType(markerTypeDefinitions, type.CustomAttributes)
.Concat(FindAspectRules(type.CustomAttributes, true));
// Loop through all methods in this type
foreach (var method in type.Methods.Where(x => x.HasBody))
{
// Find any rules applied to the method.
var methodRules = FindByMarkerType(markerTypeDefinitions, method.CustomAttributes)
.Concat(FindAspectRules(method.CustomAttributes, true));
// Join together all the rules and give them an ordering number starting at 0 for
// the highest level (assembly) to N as a lowest level (last attribute on the method)
var allRules = assemblyRules
.Concat(moduleRules)
.Concat(classRules)
.Concat(methodRules)
.Select((Rule, ScopeOrdering) => new { Rule, ScopeOrdering });
// Group the rules by the aspect type
foreach (var aspectSet in
allRules.ToLookup(x => x.Rule.MethodDecoratorAttribute.AttributeType))
{
// Sort the rules in priority order (so that attributes applied to the
// method take precedence over the type, module then assembly)
// Then pick out the first rule - this tells us whether to include
// or exclude.
var ruleList = aspectSet
.Where(x => x.Rule.Match(type, method))
.OrderBy(x => x.Rule.AttributePriority) // Apply lowest priority number first
.ThenByDescending(x => x.ScopeOrdering) // Method rules sort 1st
.Select(x => x.Rule);
var rule = ruleList.FirstOrDefault();
// If we have a rule and it isn't an exclusion, apply the method decoration.
if (rule != null && !rule.AttributeExclude)
{
decorator.Decorate(
type,
method,
rule.MethodDecoratorAttribute);
}
}
}
}
}
private void DecorateDirectlyAttributed(MethodDecorator.Fody.MethodDecorator decorator)
{
var markerTypeDefinitions = this.FindMarkerTypes();
var methods = this.FindAttributedMethods(markerTypeDefinitions.ToArray());
foreach (var x in methods)
{
decorator.Decorate(x.TypeDefinition, x.MethodDefinition, x.CustomAttribute);
}
}
public void Execute()
{
LogInfo = s => { };
LogWarning = s => { };
var markerTypeDefinitions = FindMarkerTypes();
var decorator = new MethodDecorator.Fody.MethodDecorator(ModuleDefinition);
var methods = FindAttributedMethods(markerTypeDefinitions);
foreach (var method in methods)
decorator.Decorate(method.Item1, method.Item2);
}
public override void Execute()
{
this.LogInfo = s => { };
this.LogWarning = s => { };
var decorator = new MethodDecorator.Fody.MethodDecorator(this.ModuleDefinition);
foreach (var x in this.ModuleDefinition.AssemblyReferences)
{
ResolveAssembly(x.FullName);
}
this.DecorateAttributedByImplication(decorator);
this.DecorateByType(decorator);
}
public void Execute()
{
LogInfo = s => { };
LogWarning = s => { };
var markerTypeDefinitions = FindMarkerTypes();
var decorator = new MethodDecorator.Fody.MethodDecorator(ModuleDefinition);
var methods = FindAttributedMethods(markerTypeDefinitions);
foreach (var method in methods)
{
decorator.Decorate(method.Item1, method.Item2);
}
}
private void DecorateAttributedByImplication(MethodDecorator.Fody.MethodDecorator decorator)
{
var inderectAttributes = this.ModuleDefinition.CustomAttributes
.Concat(this.ModuleDefinition.Assembly.CustomAttributes)
.Where(x => x.AttributeType.Name.StartsWith("IntersectMethodsMarkedByAttribute"))
.Select(ToHostAttributeMapping)
.Where(x => x != null)
.ToArray();
foreach (var inderectAttribute in inderectAttributes)
{
var methods = this.FindAttributedMethods(inderectAttribute.AttribyteTypes);
foreach (var x in methods)
{
decorator.Decorate(x.TypeDefinition, x.MethodDefinition, inderectAttribute.HostAttribute);
}
}
}
private void DecorateByType(MethodDecorator.Fody.MethodDecorator decorator)
{
var byTypeAttributes = this.ModuleDefinition.CustomAttributes
.Concat(this.ModuleDefinition.Assembly.CustomAttributes)
.Where(x => x.AttributeType.Resolve().Implements(typeof(IMethodDecoratorByType)))
.Distinct()
.Cast <CustomAttribute>()
.ToArray();
foreach (var attribute in byTypeAttributes)
{
var types = new List <TypeDefinition>();
var typesArgument = attribute.Properties.FirstOrDefault(arg => arg.Name == "Types").Argument;
if (typesArgument.Type != null)
{
types = ((CustomAttributeArgument[])typesArgument.Value).Select(v => v.Value).Cast <TypeDefinition>().ToList();
}
var applyToInheritedTypes = true;
var applyToInheritedArgument = attribute.Properties.FirstOrDefault(arg => arg.Name == "ApplyToInheritedTypes").Argument;
if (applyToInheritedArgument.Type != null)
{
applyToInheritedTypes = (bool)applyToInheritedArgument.Value;
}
var onlyPublicMethods = true;
var onlyPublicArgument = attribute.Properties.FirstOrDefault(arg => arg.Name == "OnlyDecoratePublicMethods").Argument;
if (onlyPublicArgument.Type != null)
{
onlyPublicMethods = (bool)onlyPublicArgument.Value;
}
if (types.Count > 0)
{
var methods = this.FindMethodsByType(types, onlyPublicMethods, applyToInheritedTypes);
foreach (var x in methods)
{
decorator.Decorate(x.TypeDefinition, x.MethodDefinition, attribute);
}
}
}
}
public void Execute()
{
this.LogInfo = s => { };
this.LogWarning = s => { };
var decorator = new MethodDecorator.Fody.MethodDecorator(this.ModuleDefinition);
foreach (var x in this.ModuleDefinition.AssemblyReferences) AssemblyResolver.Resolve(x);
this.DecorateDirectlyAttributed(decorator);
this.DecorateAttributedByImplication(decorator);
if(this.ModuleDefinition.AssemblyReferences.Count(r => r.Name == "mscorlib") > 1) {
throw new Exception(
String.Format(
"Error occured during IL weaving. The new assembly is now referencing more than one version of mscorlib: {0}",
String.Join(", ", this.ModuleDefinition.AssemblyReferences.Where(r => r.Name == "mscorlib").Select(r => r.FullName))
)
);
}
}
private void DecorateDirectlyAttributed(MethodDecorator.Fody.MethodDecorator decorator)
{
var markerTypeDefinitions = this.FindMarkerTypes();
var methods = this.FindAttributedMethods(markerTypeDefinitions.ToArray());
foreach (var x in methods)
decorator.Decorate(x.TypeDefinition, x.MethodDefinition, x.CustomAttribute);
}
private void DecorateAttributedByImplication(MethodDecorator.Fody.MethodDecorator decorator)
{
var inderectAttributes = this.ModuleDefinition.CustomAttributes
.Concat(this.ModuleDefinition.Assembly.CustomAttributes)
.Where(x => x.AttributeType.Name.StartsWith("IntersectMethodsMarkedByAttribute"))
.Select(ToHostAttributeMapping)
.Where(x=>x!=null)
.ToArray();
foreach (var inderectAttribute in inderectAttributes) {
var methods = this.FindAttributedMethods(inderectAttribute.AttribyteTypes);
foreach (var x in methods)
decorator.Decorate(x.TypeDefinition, x.MethodDefinition, inderectAttribute.HostAttribute);
}
}
