Castle.core AOP

使用

 //代理生成器
 ProxyGenerator generator = new ProxyGenerator();
 //拦截器
 MyInterceptor interceptor = new MyInterceptor();
 //代理生成器使用拦截器生成代理对象
 IDBHelper dbhelper = generator.CreateClassProxy<MySqlDBHelper>(interceptor);
 Console.WriteLine("生成的类型时：{0}", dbhelper.GetType());
 int[] c = new int[3];
 c[0] = 1;
 c[1] = 2;
 c[2] = 3;
 int c1 = 2;
 dbhelper.show(2,3,c,ref c1);
 dbhelper.show1();

其他

 public interface IDBHelper
 {
     void show(int a,int b, int[] c, ref int c1);
     void show1();
 }
 public class MySqlDBHelper : IDBHelper
 {
     public virtual void show(int a, int b, int[] c,ref int c1)
     {
         Console.WriteLine("I am Mysql");
     }
     public virtual void show1()
     {
         Console.WriteLine("I am Mysql1");
     }
 }

  
 public class MyInterceptor : StandardInterceptor
 {
     /// <summary>
     /// 调用前拦截
     /// </summary>
     /// <param name="invocation"></param>
     protected override void PreProceed(IInvocation invocation)
     {

         var parameters = invocation.Method.GetParameters();

         for (int i = 0; i < parameters.Length; i++)
         {
             var paramInfo = parameters[i];
             object argValue = invocation.Arguments[i];

             // 对参数值进行友好字符串转换，特别是处理数组
             string stringValue = ConvertArgumentToString(argValue);
             Console.WriteLine($"  参数 [{i}]: 名称={paramInfo.Name}, 类型={paramInfo.ParameterType.Name}, 值={stringValue}");
         }
         Console.WriteLine("调用前拦截,调用方法：" + invocation.Method.Name+$"参数：{ string.Join(", ", invocation.Arguments)} ");


         base.PerformProceed(invocation);
     }
     /// <summary>
     /// 将参数值转换为友好的字符串表示，特别处理数组类型。
     /// </summary>
     private string ConvertArgumentToString(object argument)
     {
         if (argument == null) return "null";

         Type argType = argument.GetType();

         // 处理数组（如 double[]）
         if (argType.IsArray)
         {
             //try
             //{
             //    return JsonSerializer.Serialize(argument);
             //}
             //catch
             {
                 return $"[{string.Join(", ", (argument as System.Array).Cast<object>())}]";
             }
         }
         return argument.ToString();

         //// 处理简单类型
         //if (argType.IsPrimitive || argType == typeof(string))
         //{
         //    return argument.ToString();
         //}

         //// 对于其他复杂对象，使用序列化
         //try
         //{
         //    return JsonSerializer.Serialize(argument, new JsonSerializerOptions { WriteIndented = false });
         //}
         //catch
         //{
         //    return argument.ToString();
         //}
     }
     /// <summary>
     /// 拦截的方法返回时调用
     /// </summary>
     /// <param name="invocation"></param>
     protected override void PerformProceed(IInvocation invocation)
     {
         Console.WriteLine("调用方法返回时拦截,调用方法：" + invocation.Method.Name);
         base.PostProceed(invocation);
     }
     /// <summary>
     /// 调用后拦截
     /// </summary>
     /// <param name="invocation"></param>
     protected override void PostProceed(IInvocation invocation)
     {
         Console.WriteLine("调用后拦截,调用方法：" + invocation.Method.Name);
         base.PreProceed(invocation);
     }