对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

===============>>#1 票数:70 已采纳

对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

===============>>#2 票数:48

对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

===============>>#3 票数:9

对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

===============>>#4 票数:8

对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

===============>>#5 票数:5

对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

===============>>#6 票数:4

对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

===============>>#7 票数:4

对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

===============>>#8 票数:4

对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

===============>>#9 票数:2

对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

===============>>#10 票数:1

对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

===============>>#11 票数:1

对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

===============>>#12 票数:1

对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

===============>>#13 票数:1

对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

===============>>#14 票数:0

对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

===============>>#15 票数:-1

对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

===============>>#16 票数:-3

对于给定的类,我想具有跟踪功能,即,我想记录每个方法调用(方法签名和实际参数值)和每个方法出口(仅方法签名)。

假设以下条件,我如何完成此操作:

  • 我不想将任何第三方AOP库用于C#,
  • 我不想将重复的代码添加到我要跟踪的所有方法中,
  • 我不想更改类的公共API-类的用户应该能够以完全相同的方式调用所有方法。

为了使问题更具体,让我们假设有3个类:

 public class Caller 
 {
     public static void Call() 
     {
         Traced traced = new Traced();
         traced.Method1();
         traced.Method2(); 
     }
 }

 public class Traced 
 {
     public void Method1(String name, Int32 value) { }

     public void Method2(Object object) { }
 }

 public class Logger
 {
     public static void LogStart(MethodInfo method, Object[] parameterValues);

     public static void LogEnd(MethodInfo method);
 }

我如何调用Logger.LogStartLogger.LogEnd每次调用方法1方法2,而无需修改Caller.Call方法,没有明确地加入调用Traced.Method1Traced.Method2?

编辑:如果允许我稍微更改Call方法,那将是解决方案?

  ask by Journeyman translate from so

未解决问题?本站智能推荐:

1回复

在代理上使用反射的c#统一调用方法

我陷入一个问题。 我有这样的一段代码: 问题是当我更换 与 一切,包括方面,都可以正常工作。 该测试是一个代理对象,如果我在该代理上调用了调用,它将抛出我 问题是我需要使用反射,你们有没有遇到过这样的问题? 感谢您的建议
8回复

使用DynamicProxy拦截对异步方法的调用

下面是实现Castle动态代理库的IInterceptor的自定义类型上的Intercept方法的代码。 此片段来自此处发布的基于AOP的日志记录概念验证控制台应用程序。 这在常规方法调用中按预期工作,但在使用async方法(使用C#5.0中的async/await关键字)尝试时则不行
7回复

如何在C#中制作简单的动态代理

我想构建一个动态代理对象,以向对象添加某些功能。 基本上,我想接收一个对象,用看起来与我得到的原始对象相同的对象包装它,并拦截所有呼叫。 为了澄清起见,我想做一些与WCF渠道工厂类似的事情... 我要加赏金,因为我需要一种好的方法来代理类(不是接口)并处理非虚拟方法(就像
1回复

C#在构造函数参数中记录“俄罗斯娃娃效果”

首先,我不确定我会用好话来形容我的问题,道歉(英语不是我的母亲)。 这是关于将记录器添加到项目中。 根据要求,应该有多个记录器,并且应该“动态”定义它们。 因此,我们最终得到了具有Logger属性的类。 但是,所有构造函数都有一个额外的参数,该参数是将logger实例与其他业务参
2回复

如何在编译时注入C#代码?

我希望能够使用自定义Trace属性修饰任何方法,并且应该在编译时将一些代码注入到该方法中。 例如: 应成为: 在这种情况下,注入的代码取决于方法名称和方法参数,因此应该可以推断出此信息。 有谁知道如何做到这一点?
3回复

使用属性调用方法

我有各种各样的方法,在继续自己的实现之前都需要执行相同的功能。 现在我可以在每个方法中实现这些函数,但我想知道是否有办法利用attributes来做到这一点? 作为一个非常简单的示例,所有网络呼叫都必须检查网络连接。 这可以工作,但我必须为使用网络的每个方法调用IsNetworkCo
1回复

比较MethodInfo和IMethodInvocation的方法

我正在使用面向方面的编程来实现日志记录系统。 因此,当调用方法时,我拦截了该调用并转到该函数: 可以使用自己的名称比较方法,但是这些方法可以重载并且属性可以不同。 直到我尝试用泛型截获方法之前,这种方式一直很好。 在这种情况下,.ToString()返回: 和
3回复

检查方法是否使用反射实现IDisposable.Dispose

是否有更正式/故障安全的方法来检查System.Reflection.MethodInfo是否引用了IDisposable.Dispose的类的实现而不是以下? 我已经知道该类实现了IDisposable ,因此Dispose存在,但我正在使用一个PostSharp方面,它应该在调用Di
1回复

如何用反射获取受保护的内部方法

我尝试在LogAttribute =>中获取方法 如何在LogAttribute中获取受保护的覆盖方法?
1回复

如何在运行时扩展方法?

这是课程: 我需要的是: 在运行时创建一个Foo2类,该类具有所有Foo类成员的副本。 在Foo2类中,将Boo方法替换为Boo2方法,该方法的内容在一定程度上有所不同。 创建Foo2的实例并调用Boo2 。 谢谢你的帮助。