Added method filtering by namespace, typename and methodname

Author: GeirLudvigsen

src/MethodBoundaryAspect.Fody/AttributeNames.cs

@@ -3,5 +3,8 @@ namespace MethodBoundaryAspect.Fody
     static class AttributeNames
     {
         public static string AttributeTargetMemberAttributes => "AttributeTargetMemberAttributes";
+        public static string NamespaceFilter => "NamespaceFilter";
+        public static string TypeNameFilter => "TypeNameFilter";
+        public static string MethodNameFilter => "MethodNameFilter";
     }
 }

src/MethodBoundaryAspect.Fody/ModuleWeaver.cs

@@ -4,6 +4,7 @@
 using System.IO;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Text.RegularExpressions;
 using Fody;
 using MethodBoundaryAspect.Fody.Ordering;
 using Mono.Cecil;
@@ -204,6 +205,9 @@ private void WeaveType(
                     .Where(IsMethodBoundaryAspect)
                     .Select(x => new AspectInfo(x))
                     .Where(info => info.HasTargetMemberAttribute(methodVisibility))
+                    .Where(info => string.IsNullOrEmpty(info.NamespaceFilter) || Regex.IsMatch(type.Namespace, info.NamespaceFilter))
+                    .Where(info => string.IsNullOrEmpty(info.TypeNameFilter) || Regex.IsMatch(type.Name, info.TypeNameFilter))
+                    .Where(info => string.IsNullOrEmpty(info.MethodNameFilter) || Regex.IsMatch(method.Name, info.MethodNameFilter))
                     .Where(x => !IsSelfWeaving(type, x))
                     .ToList();
                 if (aspectInfos.Count == 0)

src/MethodBoundaryAspect.Fody/Ordering/AspectInfo.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Mono.Cecil;
@@ -27,6 +28,9 @@ public AspectInfo(CustomAttribute aspectAttribute)
             InitSkipProperties(aspectAttributes);
             InitTargetMembers();
             InitChangingInputArguments(aspectAttributes);
+            InitNamespaceFilter();
+            InitTypeNameFilter();
+            InitMethodNameFilter();
         }
 
         public TypeDefinition AspectTypeDefinition { get; }
@@ -49,6 +53,10 @@ public AspectInfo(CustomAttribute aspectAttribute)
 
         public bool AllowChangingInputArguments { get; private set; }
 
+        public string NamespaceFilter { get; set; }
+        public string TypeNameFilter { get; set; }
+        public string MethodNameFilter { get; set; }
+
         public IEnumerable<MethodAttributes> AttributeTargetMemberAttributes { get; set; } =
             new List<MethodAttributes>
             {
@@ -199,5 +207,47 @@ private void InitChangingInputArguments(IEnumerable<CustomAttribute> aspectAttri
                 .Any(c => c.AttributeType.FullName == AttributeFullNames.AllowChangingInputArguments);
 
         }
+
+        private void InitNamespaceFilter()
+        {
+            var namespaceFilterArgument = AspectAttribute.Properties
+                .FirstOrDefault(property => property.Name == AttributeNames.NamespaceFilter);
+
+            if (namespaceFilterArgument.Equals(default(CustomAttributeNamedArgument)))
+                return;
+
+            if (!(namespaceFilterArgument.Argument.Value is string argumentValue))
+                return;
+
+            NamespaceFilter = argumentValue;
+        }
+
+        private void InitTypeNameFilter()
+        {
+            var typeNameFilterArgument = AspectAttribute.Properties
+                .FirstOrDefault(property => property.Name == AttributeNames.TypeNameFilter);
+
+            if (typeNameFilterArgument.Equals(default(CustomAttributeNamedArgument)))
+                return;
+
+            if (!(typeNameFilterArgument.Argument.Value is string argumentValue))
+                return;
+
+            TypeNameFilter = argumentValue;
+        }
+
+        private void InitMethodNameFilter()
+        {
+            var methodNameFilterArgument = AspectAttribute.Properties
+                .FirstOrDefault(property => property.Name == AttributeNames.MethodNameFilter);
+
+            if (methodNameFilterArgument.Equals(default(CustomAttributeNamedArgument)))
+                return;
+
+            if (!(methodNameFilterArgument.Argument.Value is string argumentValue))
+                return;
+
+            MethodNameFilter = argumentValue;
+        }
     }
 }

src/MethodBoundaryAspect/Attributes/OnMethodBoundaryAspect.cs

@@ -8,6 +8,10 @@ public abstract class OnMethodBoundaryAspect : Attribute
         public MulticastAttributes AttributeTargetMemberAttributes { get; set; } =
             MulticastAttributes.AnyVisibility;
 
+        public virtual string NamespaceFilter { get; set; }
+        public virtual string TypeNameFilter { get; set; }
+        public virtual string MethodNameFilter { get; set; }
+
         public virtual void OnEntry(MethodExecutionArgs arg)
         {
         }