[Aspect("contains(@Name,'Test')")] // Это метаатрибут, в котором задается, к каким классам будет применена трансформация.
public class MyAspect
{
    [PointCut] // Это метаатрибут, который объявляет, что это шаблонный метод.
    public void MyMethod(int x, string s) // По сигнатуре метода можно получить фильтр для XPath, по которому выбираются методы, которые нужно трансформировать.
    {
        // Код, который нужно выполнить до вызова метода.
        MyMethod(x, s); // Это не рекурсивный вызов, а точка, куда нужно подставить потроха преобразуемого метода.
        // Код, который нужно выполнить после вызова метода.
    }
}

public class Test1
{
    public void MyTest1(int x, string s)
    {
        // Код матода.
    }
}

public class Test1
{
    public void MyTest1(int x, string s)
    {
        // Код, который нужно выполнить до вызова метода.
        InternalMyTest1(x, s); // Это вместо вызова MyMethod(x, s); в определнии аспекта.
        // Код, который нужно выполнить после вызова метода.
    }

    private void InternalMyTest1(int x, string s)
    {
        // Код матода.
    }
}

  [NodeName("class")]
  public class RTypeClass : RTypeUdt // обрати внимание! При генерации учитываются члены базового класса
  {
    public abstract RTypeClass NextPart
    {
      get; 
      set; 
    }
}

[NodeName("class")]
public class RTypeClass : RTypeUdt
{
    #line default
    
    
    RTypeClass _nextPart;
    #line 25 "..\..\..\rsctest\codedom\types\RTypeClass.cs"
    
    public RTypeClass NextPart
    {
        get
        {
            #line default
            
            return _nextPart;
        }
        set
        {
            #line default
            
            if (value.Parent != null)
                _nextPart = ((RTypeClass)(value.Clone()));
            else
                _nextPart = value;
            value.Parent = this;
        }
    }
    [RSParser.CodeDom.Design.TypeID(TypeID.RTypeClass)]
    public override TypeID TypeID
    {
        get
        {
            return TypeID.RTypeClass;
        }
    }
    public override AstNode Clone()
    {
        RTypeClass clone = new RTypeClass();
        clone.BaseTypes.AddRange(this.BaseTypes);
        clone.Members.AddRange(this.Members);
        clone.TypeParameters.AddRange(this.TypeParameters);
        clone.CustomAttributeSections.AddRange(this.CustomAttributeSections);
        clone.Name = this.Name;
        clone.Modifiers = this.Modifiers;
        clone.StartLocation = this.StartLocation;
        clone.EndLocation = this.EndLocation;
        clone.FileName = this.FileName;
        {
            RTypeClass temp = this.NextPart;
            if (temp != null)
                clone.NextPart = ((RTypeClass)(temp.Clone()));
        }
        #line default
        
        return clone;
    }
    #line default
    
    public override IDomContainer GetChild(int index)
    {
        switch (index)
        {
        case 0:
            return this.BaseTypes;
        case 1:
            return this.Members;
        case 2:
            return this.TypeParameters;
        case 3:
            return this.CustomAttributeSections;
        case 4:
            return this.NextPart;
        }
        throw new ArgumentException("Illegal index.");
    }
    public override int GetChildCount()
    {
        return 5;
    }
    public override string[] GetChildNames()
    {
        return _childNames;
    }
    public override int[] GetWritableStringPropertyIndices()
    {
        return _writableStringPropertyIndices;
    }
    public override int[] GetStringPropertyIndices()
    {
        return _stringPropertyIndices;
    }
    public override string[] GetPropertyNames()
    {
        return _propertyNames;
    }
    
    private readonly static string[] _childNames = 
    {
        #line default
        "NextPart","BaseTypes","Members","TypeParameters","CustomAttributeSections"
    };
    #line default
    
    
    private readonly static string[] _propertyNames = 
    {
        #line default
        "Name","Modifiers","StartLocation","EndLocation","FileName","TypeCode",
    "NamespaceName","FullName","TypeID"
    };
    #line default
    
    
    protected new static int[] _stringPropertyIndices = 
    {
        #line default
        0,4,6,7
    };
    #line default
    
    
    protected new static int[] _writableStringPropertyIndices = 
    {
        #line default
        0,4
    };
    #line default
    
    public override void AcceptVisitor(IAstVisitor visitor)
    {
        visitor.Visit(this);
    }
}

public int MyMethod(int x,string y)

.//RMemberMethodImpl[.//RParameter/Type[1]/@Name='int' and .//RParameter/Type[2]/@Name='string']

VD>Это намного сложнее чем АОП, так как подставляемая реализация автоматически генерируется по определенному алгоритму. Так что сделать АОП вообще не сложная задача. Вот только у меня и так много проблем. Нужно доделать самогенерацию кода R#, а у меня на работе полный завал.

using System;

namespace AOP.FrameWork
{
    [Aspect("contains(@Name,'Test')")]
    public class Aspect
    {
        public Aspect()
        {
        }

        [PointCut]
        public void MyMethod(int x, string y)
        {
            try
            {
                if(true)
                    MyMethod(x, y);
                else
                    MyMethod(x+1, y+"qqq");
                string s = string.Format("aaa {0}", 1);
            }
            catch (Exception e)
            {
                throw;
            }
        }
    }
}

namespace AOP.Test
{
    public class Test1
    {
        public void MyMethod1(int x)
        {
            int z = x * x;
        }

        public void MyMethod2(int y, string s)
        {
            int z = y + s.Length;
        }
    }

    public class Test2
    {
        public int MyMethod1(int x)
        {
            return x * x;
        }

        public int MyMethod2(int y, string s)
        {
            return y + s.Length;
        }
    }
}

namespace AOP.Test
{
    public class Test1
    {
        public void MyMethod1(int x)
        {
            int z = x * x;
        }
        public void InternalMyMethod2(int y, string s)
        {
            int z = y + s.Length;
        }
        [PointCut]
        public void MyMethod2(int x, string y)
        {
            try
            {
                if (true)
                    InternalMyMethod2(x, y);
                else
                    InternalMyMethod2(x + 1, y + "qqq");
                string s = string.Format("aaa {0}", 1);
            }
            catch(Exception e)
            {
                throw;
            }
        }
    }

    public class Test2
    {
        public int MyMethod1(int x)
        {
            return x * x;
        }
        public int MyMethod2(int y, string s)
        {
            return y + s.Length;
        }
    }
}

#region Using directives

using System;
using System.Text;
using System.Xml.XPath;

using RSharp.Query;
using RSParser.Engine;
using RSParser.CodeDom;

#endregion

namespace AOP.FrameWork
{
    public class AspectCompiler
    {
        #region Конструктор.

        private string _aspectFileName;
        private string _targetFileName;

        public AspectCompiler(string aspectFileName, string targetFileName)
        {
            _aspectFileName = aspectFileName;
            _targetFileName = targetFileName;
        }

        #endregion

        #region Свойства

        private RCompileUnit _aspectCompileUnit;
        public RCompileUnit AspectCompileUnit
        {
            get
            {
                if (_aspectCompileUnit == null)
                {
                    Scanner scanner = new Scanner();
                    scanner.InitFromFile(_aspectFileName);
                    Parser parser = new Parser(scanner);
                    parser.Parse();
                    _aspectCompileUnit = parser.CompileUnit;
                }
                return _aspectCompileUnit;
            }
        }

        private RCompileUnit _targetCompileUnit;
        private RCompileUnit TargetCompileUnit
        {
            get
            {
                if (_targetCompileUnit == null)
                {
                    Scanner scanner = new Scanner();
                    scanner.InitFromFile(_targetFileName);
                    Parser parser = new Parser(scanner);
                    parser.Parse();
                    _targetCompileUnit = parser.CompileUnit;
                }
                return _targetCompileUnit;
            }
        }

        private string CompiledCode
        {
            get
            {
                RSParser.CodeDom.CS csVistor = new CS(false);
                TargetCompileUnit.AcceptVisitor(csVistor);
                return csVistor.ToString();
            }
        }

        #endregion

        #region Трансформация

        /// <summary>
        /// Перебор методов аспекта, поиск классов и методов, которые нужно преобразовать.
        /// </summary>
        /// <returns>Перобразованный код.</returns>
        public string ApplyTransformations()
        {
            string aspectXPath = "//class[.//attribute/@Name='Aspect']";
            string pointCutXPath = ".//RMemberMethodImpl[.//attribute/@Name='PointCut']";

            Navigator aspectCompileUnitNavigator = new Navigator(AspectCompileUnit);
            XPathNodeIterator aspectIterator = aspectCompileUnitNavigator.Select(aspectXPath);

            foreach (Navigator aspectNavigator in aspectIterator)
            {
                RTypeClass aspectClass = (RTypeClass)aspectNavigator.Current;

                Navigator targetCompileUnitNavigator = new Navigator(TargetCompileUnit);
                XPathNodeIterator targetClassIterator = targetCompileUnitNavigator.Select(GetClassXPath(aspectClass));
                foreach (Navigator targetClassNavigator in targetClassIterator)
                {
                    XPathNodeIterator pointCutIterator = aspectNavigator.Select(pointCutXPath);
                    foreach (Navigator pointCutNavigator in pointCutIterator)
                    {
                        string targetMethodXPath = GetMethodXPath((RMemberMethodImpl)pointCutNavigator.Current);
                        XPathNodeIterator targetIterator = targetClassNavigator.Select(targetMethodXPath);
                        foreach (Navigator targetNavigator in targetIterator)
                            ApplyTransformations((RMemberMethodImpl)targetNavigator.Current, (RMemberMethodImpl)pointCutNavigator.Current);
                    }
                }
            }

            return CompiledCode;
        }

        /// <summary>
        /// Здесь идет сама трансформация AST.
        /// </summary>
        /// <param name="targetMethod">Метод, который нужно преобразовать.</param>
        /// <param name="pointCut">Шаблонный метод.</param>
        private void ApplyTransformations(RMemberMethodImpl targetMethod, RMemberMethodImpl pointCut)
        {
            // Трансформация сводится к копированию метода из аспекта в целевой класс,
            // предварительно переименовав его, с последующей заменой некоторых кусков кода.
            RMemberMethodImpl copyOfPointCutMethod = (RMemberMethodImpl)pointCut.Clone();

            // В методах аспекта для указания точки входа в преобразуемый метод используется
            // рекурсивный вызов. Данный кусок кода меняет все эти вызовы на вызовы InternalXXX,
            // где XXX - имя преобразуемого метода.
            string replaceCallsXPath = string.Format("//*[@VariableName='{0}']", pointCut.Name);
            Navigator callsNavigator = new Navigator(copyOfPointCutMethod);
            foreach (Navigator callNavigator in callsNavigator.Select(replaceCallsXPath))
                ((RUnresolvedReferenceExpression)callNavigator.Current).VariableName = "Internal" + targetMethod.Name;

            // Реально целевой метод не меняется, а заменяется на свой враппер.
            copyOfPointCutMethod.Name = targetMethod.Name;
            targetMethod.Name = "Internal" + targetMethod.Name;

            ((RTypeMemberCollection)targetMethod.Parent).Add(copyOfPointCutMethod);
        }

        #endregion

        #region static методы.

        /// <summary>
        /// У аспекта должен быть атрибут Aspect, который может иметь параметр - фильтр.
        /// Если фильтр задан, то получим нечто типа //class[filter]
        /// </summary>
        /// <param name="aspectClass">Класс аспекта.</param>
        /// <returns>XPath для выбора классов, методы которых должны подвергнуться преобразованию.</returns>
        private static string GetClassXPath(RTypeClass aspectClass)
        {
            RAttributeDeclaration aspectAttributeDeclaration = aspectClass.CustomAttributes.Find("Aspect");
            if (aspectAttributeDeclaration == null)
                throw new Exception("Ожидался атрибут [Aspect]");

            switch (aspectAttributeDeclaration.Arguments.Count)
            {
                case 0:
                    return "//class";
                case 1:
                    RPrimitiveExpression filterExpression = (RPrimitiveExpression)aspectAttributeDeclaration.Arguments[0].Value;
                    return string.Format("//class[{0}]",filterExpression.Value.Trim('"'));
                default:
                    throw new Exception("У атрибута Aspect может быть только один параметр - XPath фильтр.");
            }
        }

        /// <summary>
        /// Используя сигнатуру метода в аспекте генерирует XPath, учитывая количество параметров,
        /// тип возвращаемого значения, типы параметров метода.
        /// </summary>
        /// <param name="pointCutMethod">Метод, определнный в аспекте, и содержимое котрого нужно скопировать в свой код.</param>
        /// <returns>XPath для выбора методов(относительно класса), которые енужно преобразовать.</returns>
        private static string GetMethodXPath(RMemberMethodImpl pointCutMethod)
        {
            int position = 0;

            StringBuilder methodFilterBuilder = new StringBuilder();
            methodFilterBuilder.AppendFormat(
                ".//RMemberMethodImpl[./ReturnType[TypeName='{0}']",
                ((RNonArrayTypeReference)pointCutMethod.ReturnType).TypeName);

            foreach (RParameterDeclarationExpression prm in pointCutMethod.Parameters)
            {
                methodFilterBuilder.AppendFormat(
                    " and .//RParameterDeclarationExpression[{0}]/Type/TypeName='{1}'",
                    ++position,
                    ((RNonArrayTypeReference)prm.Type).TypeName);
            }

            methodFilterBuilder.AppendFormat(" and count(.//RParameterDeclarationExpression)={0}]", position);
            return methodFilterBuilder.ToString();
        }

        #endregion
    }
}

GR>namespace AOP.FrameWork

GR>    [Aspect("contains(@Name,'Test')")]
GR>    public class Aspect

...
GR>namespace AOP.FrameWork

GR>    public class AspectCompiler
GR>    {

RSharp\RSharp.Rules\AstNodeImplRule.cs
RSharp\RSharp.Rules\VisitorRule.cs

[PointCut]

public void MyMethod(
    int x, 
    [Pattern(T = "string | System.Text.StringBuilder")]
    T y)
{
...

[PointCut]
[MatchAnyParameters]
[RequireParam(a = XPath("некторый XPath-запрос парамета"))]
[OptionalParam(b = XPath("другой XPath-запрос"))]
public void MyMethod()
{
...

VD>Наверно пространство имен лучше назвать как-то по другому. Хотя опять же для абстрактного примера это не просто.

GR>>    [Aspect("contains(@Name,'Test')")]
GR>>    public class Aspect
VD>

//class[contains(@Name,'Test')]

VD>Если учесть, что это реализация АОП-а, то не так все страшно. Все же не часто найдешь технологию способную вот так вот с ходу реализовать компайл-тайм-АОП. Ну, да чем проще тем лучше. По позже гляну.

VD>[PointCut]

VD>public void MyMethod(
VD>    int x, 
VD>    [Pattern(T = "string | System.Text.StringBuilder")]
VD>    T y)
VD>{
VD>...
VD>

Метод: MyMethod
    Аргумент: int x = 10
    Аргумент: string s = "test"

VD>[PointCut]
VD>[MatchAnyParameters]
VD>[RequireParam(a = XPath("некторый XPath-запрос парамета"))]
VD>[OptionalParam(b = XPath("другой XPath-запрос"))]
VD>public void MyMethod()
VD>{
VD>...
VD>

GR>Было бы что называть — название придумаем

GR>//class[contains(@Name,'Test')]
GR>

GR>Метод: MyMethod
GR>    Аргумент: int x = 10
GR>    Аргумент: string s = "test"
GR>

... SomeMethod(...)
{
    ...
    Log(Meta.Method.Name);
    Log(Meta.Method.Argumens);
    ...
}

... SomeMethod(int i, string s)
{
    ...
    Log("SomeMethod");
    object[] @MethodArgumens = new object[] { i , s };
    Log(@MethodArgumens);
    ...
}

... SomeMethod(...)
{
    ...
    Log(Meta.Method.Name);
    Meta.ForEach(Meta.Method.Argumens, param, Log(param));
    ...
}

... SomeMethod(int i, string s)
{
    ...
    Log("SomeMethod");
    Log(i);
    Log(s);
    ...
}

VD>>[PointCut]
VD>>[MatchAnyParameters]
VD>>[RequireParam(a = XPath("некторый XPath-запрос парамета"))]
VD>>[OptionalParam(b = XPath("другой XPath-запрос"))]
VD>>public void MyMethod()
VD>>{
VD>>...
VD>>

VD>ну, то-есть ввести мета-конструкцию которая развернется более чем в одну строку кода. Ну, а уже сам вызываемый метод (в данном случае Log()) будет перегружен для всех встречающихся типов. В принципе такие вещи не совсем АОП, но это даже круче. Это настоящее мета-программирование. Именно ради этого я и затеевал весь этот R# .

public class TestClass
{
    public int TestMethod(string s)
    {
        // Код класса.
    }
}

public class TestClass
{
    // Просто переименованный метод.
    private int @TestMethod(string s)
    {
        // Код класса.
    }

    // Это AOP обертка.
    public int TestMethod(string s)
    {
        // Код аспекта.
        @TestMethod(string s) // Вот это место я называл "точкой входа".
        // Код аспекта.
    }
}

public class TestClass
{
    public int TestMethod(int x, string s)
    {
        // Код класса.
    }
        public int TestMeth2(params object[] q)
        {
        // Код класса.
        }
}

[Aspect("contains(@Name,'Test')")] .
public class MyAspect
{
    [PointCut] 
    public int MyMethod
         [ExpandedMatch] // метаатрибут, который говорит о необходимости расширить матчинг следующего параметра. Без него поймается TestMeth2, а не TestMethod.
         params object[] pars)
    {
        Log.Write("Going to call MyMethod with these param values: ", pars);
        int i = MyMethod(pars); // Это не рекурсивный вызов, а точка, куда нужно подставить потроха преобразуемого метода.
        Log.Write("Called MyMethod with these param values: ", pars);
                return i;
    }
}

public class TestClass
{
    private int @TestMethod(int x, string s)
        {
        // Код класса.
        }
    public int TestMethod(int x, string s)
    {
          object[] pars = new object[]{x, s};
        Log.Write("Going to call MyMethod with these param values: ", pars);
        int i = @TestMethod(x, s); 
        Log.Write("Called MyMethod with these param values: ", pars);
                return i;
    }
        public int TestMeth2(params object[] q)
        {
        // Код класса.
        }
}

Здесь подразумевается приведенный вами код.

[Aspect]
public class MyAspect
{
        public void MyMethod
        (
            [DerivedTypeMatch] object obj,      // obj может быть любого типа
            [DerivedTypeMatch] XmlReader reader // reader может быть XmlNodeReader, XmlTextReader, XmlValidatingReader и т.д. 
        )
        {
            // Код аспекта.
        }    
        
}

    public int MyMethod
    (
        [ExpandedMatch] params string[] pars // 1 или более аргументов типа string или производных от string. Сомнительно, что такой паттрен будет полезен, но все таки...
    )
    {
        // Код аспекта
    }

    public int MyMethod
    (
        [ExpandedMatch] string str // 1 аргумент типа string или производный от string.
    )
    {
        // Код аспекта
    }

    public int MyMethod
    (
        [ExpandedMatch] string[] pars // 1 или более аргументов типа string или производных от string. Сомнительно, что такой паттрен будет полезен, но все таки...
    )
    {
        // Код аспекта
    }

    public int MyMethod
    (
        [ExpandedMatch] string str // 1 аргумент типа string или производный от string.
    )
    {
        // Код аспекта
    }

        // Паттерны по умолчанию.
        public static void Test1(int x,string s,
            string[] pars){} // Один параметр типа string[]. 

        public static void Test2(int x,string s,
            params string[] pars){} // Один параметр типа params string[]

        // Применение [ExpandedMatch]
        public static void Test3(int x,string s,
            [ExpandedMatch] string[] pars){} // Один параметр типа params string[]. [ExpandedMatch] игнорируется.

        public static void Test4(int x,string s,
            [ExpandedMatch] params string[] pars){} // 1 или больше параметров типа string

        // Применение [DerivedTypeMatch]
        public static void Test5(int x,string s,
            [DerivedTypeMatch] MyType[] pars){} // Один параметр типа MyType[] или DerivedMyType[].

        public static void Test6(int x,string s,
            [DerivedTypeMatch] params MyType[] pars){} // Один параметр типа params MyType[] или params DerivedMyType[].

        // Комбинированное применение [ExpandedMatch] и [DerivedTypeMatch]
        public static void Test7(int x,string s,
            [ExpandedMatch, DerivedTypeMatch] MyType[] pars){} // Один параметр типа MyType[] или DerivedMyType[]. [ExpandedMatch] игнорируется.

        public static void Test8(int x,string s,
            [ExpandedMatch, DerivedTypeMatch] params MyType[] pars){} // 1 или больше параметров типа MyType или DerivedMyType.

GR>Но это скорее в философию программирования

GR>    public int MyMethod
GR>    (
GR>        [ExpandedMatch] params string[] pars // 1 или более аргументов типа string или производных от string. Сомнительно, что такой паттрен будет полезен, но все таки...
GR>    )
GR>    {
GR>        // Код аспекта
GR>    }

GR>    public int MyMethod
GR>    (
GR>        [ExpandedMatch] string str // 1 аргумент типа string или производный от string.
GR>    )
GR>    {
GR>        // Код аспекта
GR>    }
GR>

    public int MyMethod
    (
        [Match("XPath-запрос 1")] string[] pars1,
        [Match("XPath-запрос 2")] int[]    pars2,
        [Match("XPath-запрос 2")] Xxx[]    pars3
    )
    {
        // Код аспекта
    }

VD>А то что у тебя выресовывается действительно на него похоже. Вот только ПМ рассчитан на подбор вызова метода по значению его параметров, а у тебя подбор мета-описания вызва метода по типу параметров. Так что это скорее мета-перегрузка.

VD>    public int MyMethod
VD>    (
VD>        [Match("XPath-запрос 1")] string[] pars1,
VD>        [Match("XPath-запрос 2")] int[]    pars2,
VD>        [Match("XPath-запрос 2")] Xxx[]    pars3
VD>    )
VD>    {
VD>        // Код аспекта
VD>    }
VD>

#region Meta.ID(ForEachArgument)
    Console.WriteLine("Аргумент {0} = {1}", Argument.Name, Argument.Value);
#endregion