1
public class Person : MarshalByRefObject {
2
  public string Say(string word) {
3
    return $"Hello,{word}!";
4
  }
5
}

1
public class PersonAspect {
2
  [Around(typeof(string))]
3
  public void Say(JoinPoint joinPoint) {
4
    var args = joinPoint.args;
5
    Console.WriteLine("调用之前：收到了" + args[0]);
6
    var result = joinPoint.Procced();
7
    Console.WriteLine("调用之后：结果是" + result);
8
  }
9
}

1
static void Main(string[] args) {
2
  Person p = (Person) new AopRealProxy(typeof(Person), null, typeof(PersonAspect), null).GetTransparentProxy();
3
  p.Say("World");
4
  Console.Read();
5
}

1
using System;
2
using System.Runtime.Remoting.Messaging;
3

4
namespace KanameFramework.Core.Aop {
5

6
  /// <summary>
7
  /// 切点
8
  /// </summary>
9
  public class JoinPoint {
10

11
    public object[] args;
12
    private Func<IMethodReturnMessage> procced;
13

14
    public IMethodReturnMessage MethodReturnMessage { get; private set; }
15

16
    public JoinPoint(object[] args, Func<IMethodReturnMessage> procced) {
17
      this.args = args;
18
      this.procced = procced;
19
    }
20

21
    /// <summary>
22
    /// 执行原方法
23
    /// </summary>
24
    public object Procced() {
25
      MethodReturnMessage = procced.Invoke();
26
      return MethodReturnMessage.ReturnValue;
27
    }
28

29
  }
30

31
}

1
using System;
2

3
namespace KanameFramework.Core.Aop.Attributes {
4
  /// <summary>
5
  /// 标记此方法为环绕通知
6
  /// </summary>
7
  [AttributeUsage(AttributeTargets.Method)]
8
  public class AroundAttribute: Attribute {
9

10
    /// <summary>
11
    /// 方法的参数列表,用于寻找(重载的)方法
12
    /// </summary>
13
    public Type[] ArgTypes { get; private set; }
14

15
    public AroundAttribute() {
16
      ArgTypes = new Type[0];
17
    }
18

19
    public AroundAttribute(params Type[] argTypes) {
20
      ArgTypes = argTypes;
21
    }
22
  }
23
}

1
using KanameFramework.Core.Aop.Attributes;
2
using System;
3
using System.Linq;
4
using System.Reflection;
5
using System.Runtime.Remoting;
6
using System.Runtime.Remoting.Channels;
7
using System.Runtime.Remoting.Messaging;
8
using System.Runtime.Remoting.Proxies;
9
using System.Security.Permissions;
10

11
namespace KanameFramework.Core.Aop {
12

13
  /// <summary>
14
  /// 提供动态代理的基本功能
15
  /// </summary>
16
  public class AopRealProxy : RealProxy {
17

18
    private string URI;
19
    private Type aspectType;
20
    private object aspectInstance;
21

22
    /// <summary>
23
    /// 组合目标类和切面类
24
    /// </summary>
25
    /// <param name="type">目标类</param>
26
    /// <param name="typeIns">目标类实例</param>
27
    /// <param name="aspectType">切面类</param>
28
    /// <param name="aspectIns">切面类实例</param>
29
    [PermissionSet(SecurityAction.LinkDemand)]
30
    public AopRealProxy(Type type,object typeIns,Type aspectType, object aspectIns) : base(type) {
31
      this.aspectType = aspectType;
32
      this.aspectInstance = aspectIns??Activator.CreateInstance(aspectType);
33
      URI = RemotingServices.Marshal((MarshalByRefObject)(typeIns??Activator.CreateInstance(type))).URI;
34
    }
35

36
    [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure)]
37
    public override IMessage Invoke(IMessage message) {
38

39
      //获取参数值
40
      var properties = message.Properties;
41
      var methodName = (string)properties["__MethodName"];
42
      var argTypes = (Type[])properties["__MethodSignature"];
43
      var args = (object[])properties["__Args"];
44

45
      //切面类匹配到的的方法
46
      var matchAspectMethods = aspectType.GetMethods(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Instance).Where(m=> {
47
        if (!m.Name.Equals(methodName)) return false;
48
        var attr = m.GetCustomAttribute<AroundAttribute>();
49
        if (attr == null) return false;
50
        return attr.ArgTypes.SequenceEqual(argTypes);
51
      });
52

53
      //确定执行前设置uri
54
      properties["__Uri"] = URI;
55

56
      //切面类没有对应方法直接返回
57
      if (matchAspectMethods.Count()<1)
58
        return (IMethodReturnMessage)ChannelServices.SyncDispatchMessage(message);
59

60
      //交给切面类执行
61
      var joinPoint = new JoinPoint(args, () => (IMethodReturnMessage)ChannelServices.SyncDispatchMessage(message));
62
      matchAspectMethods.First().Invoke(aspectInstance, new object[] { joinPoint });
63
      return joinPoint.MethodReturnMessage;
64
    }
65
  }
66
}