Programing

C #에서 메소드 호출을 인터셉트하려면 어떻게해야합니까?

lottogame 2020. 6. 15. 08:18
반응형

C #에서 메소드 호출을 인터셉트하려면 어떻게해야합니까?


주어진 클래스에 대해 추적 기능을 원합니다. 즉 모든 메소드 호출 (메소드 서명 및 실제 매개 변수 값) 및 모든 메소드 종료 (메소드 서명)를 기록하고 싶습니다.

다음을 가정하여 이것을 어떻게 수행합니까?

  • C #에 타사 AOP 라이브러리를 사용하고 싶지 않습니다.
  • 추적하려는 모든 메소드에 중복 코드를 추가하고 싶지 않습니다.
  • 클래스의 공개 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);
 }

Caller.Call 메서드 를 수정 하지 않고 Traced.Method1Traced.Method2에 명시 적으로 호출을 추가 하지 않고 Method1Method2호출 할 때마다 Logger.LogStartLogger.LogEnd어떻게 호출 합니까?

편집 : Call 메소드를 약간 변경할 수 있다면 어떻게 될까요?


C #은 AOP 지향 언어가 아닙니다. 일부 AOP 기능이 있으며 다른 일부를 에뮬레이트 할 수 있지만 C #으로 AOP를 만드는 것은 고통 스럽습니다.

나는 당신이하고 싶은 일을 정확하게 할 수있는 방법을 찾았고 쉬운 방법을 찾지 못했습니다.

내가 이해 한 것처럼, 이것은 당신이하고 싶은 일입니다.

[Log()]
public void Method1(String name, Int32 value);

이를 위해 두 가지 주요 옵션이 있습니다.

  1. MarshalByRefObject 또는 ContextBoundObject에서 클래스를 상속하고 IMessageSink에서 상속되는 속성을 정의하십시오. 이 기사 에는 좋은 예가 있습니다. 그럼에도 불구하고 MarshalByRefObject를 사용하면 성능이 지옥처럼 떨어질 것이라고 생각해야하며, 10 배의 성능 손실에 대해 이야기하고 있으므로 시도하기 전에 신중하게 생각하십시오.

  2. 다른 옵션은 코드를 직접 주입하는 것입니다. 런타임에 리플렉션을 사용하여 모든 클래스를 "읽고"속성을 가져 와서 적절한 호출을 주입해야합니다 (그 문제에 대해서는 Reflection.Emit 메소드를 사용할 수 없다고 생각합니다. 기존 방법에 새 코드를 삽입 할 수 없습니다). 디자인 타임에 이것은 CLR 컴파일러에 대한 확장을 만드는 것을 의미합니다.

마지막 옵션은 IoC 프레임 워크를 사용하는 것 입니다. 어쩌면 대부분의 IoC 프레임 워크가 메소드를 후크 할 수있는 진입 점을 정의하여 작동하기 때문에 완벽한 솔루션이 아닐 수도 있지만 달성하려는 목표에 따라 공정한 근접성이 될 수 있습니다.


이를 달성하는 가장 간단한 방법은 아마도 PostSharp 를 사용하는 것입니다 . 적용하는 속성에 따라 메소드 내부에 코드를 삽입합니다. 원하는대로 정확하게 할 수 있습니다.

또 다른 옵션은 프로파일 링 API 를 사용 하여 메소드 내부에 코드를 삽입하는 것이지만 실제로는 하드 코어입니다.


IDisposable 인터페이스를 구현하는 클래스 (Tracing이라고 함)를 작성하면 모든 메소드 본문을

Using( Tracing tracing = new Tracing() ){ ... method body ...}

Tracing 클래스에서는 생성자 / Dispose 메소드의 추적 논리를 각각 Tracing 클래스에서 처리하여 메소드의 시작 및 종료를 추적 할 수 있습니다. 그런 :

    public class Traced 
    {
        public void Method1(String name, Int32 value) {
            using(Tracing tracer = new Tracing()) 
            {
                [... method body ...]
            }
        }

        public void Method2(Object object) { 
            using(Tracing tracer = new Tracing())
            {
                [... method body ...]
            }
        }
    }

Castle Windsor 와 같은 DI 컨테이너의 가로 채기 기능으로 이를 달성 할 수 있습니다 . 실제로 특정 속성으로 장식 된 메소드가있는 모든 클래스를 가로 채도록 컨테이너를 구성 할 수 있습니다.

지점 # 3과 관련하여 OP는 AOP 프레임 워크가없는 솔루션을 요청했습니다. 다음 답변에서 피해야 할 것은 Aspect, JointPoint, PointCut 등이라고 가정했습니다. CastleWindsor의 인터 셉션 문서 에 따르면 요청 된 사항을 달성하는 데 필요한 것은 없습니다.

속성의 존재 여부에 따라 인터셉터의 일반 등록을 구성하십시오.

public class RequireInterception : IContributeComponentModelConstruction
{
    public void ProcessModel(IKernel kernel, ComponentModel model)
    {
        if (HasAMethodDecoratedByLoggingAttribute(model.Implementation))
        {
            model.Interceptors.Add(new InterceptorReference(typeof(ConsoleLoggingInterceptor)));
            model.Interceptors.Add(new InterceptorReference(typeof(NLogInterceptor)));
        }
    }

    private bool HasAMethodDecoratedByLoggingAttribute(Type implementation)
    {
        foreach (var memberInfo in implementation.GetMembers())
        {
            var attribute = memberInfo.GetCustomAttributes(typeof(LogAttribute)).FirstOrDefault() as LogAttribute;
            if (attribute != null)
            {
                return true;
            }
        }

        return false;
    }
}

작성된 IContributeComponentModelConstruction을 컨테이너에 추가

container.Kernel.ComponentModelBuilder.AddContributor(new RequireInterception());

인터셉터 자체에서 원하는 모든 것을 할 수 있습니다

public class ConsoleLoggingInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        Console.Writeline("Log before executing");
        invocation.Proceed();
        Console.Writeline("Log after executing");
    }
}

로깅 할 메소드에 logging 속성을 추가하십시오

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

     [Log]
     public void Method2(Object object) { }
 }

클래스의 일부 메소드 만 인터셉트해야하는 경우 일부 속성 처리가 필요합니다. 기본적으로 모든 공용 메소드는 인터셉트됩니다.


제한없이 (코드 적응, AOP 프레임 워크, 중복 코드 없음) 메소드를 추적하려면 마술이 필요합니다.

심각하게 런타임에 작동하는 AOP 프레임 워크를 구현하도록 해결했습니다.

당신은 여기에서 찾을 수 있습니다 NConcern .NET AOP 프레임 워크

이런 종류의 요구에 부응하기 위해이 AOP 프레임 워크를 만들기로 결정했습니다. 매우 가벼운 간단한 라이브러리입니다. 홈페이지에서 로거의 예를 볼 수 있습니다.

타사 어셈블리를 사용하지 않으려는 경우 코드 소스 (오픈 소스)를 탐색하고 Aspect.Directory.csAspect.Directory.Entry.cs 파일을 모두 원하는대로 복사 할 수 있습니다 . 이러한 클래스를 사용하면 런타임에 메소드를 대체 할 수 있습니다. 라이센스를 존중하라고 부탁합니다.

필요한 것을 찾거나 AOP 프레임 워크를 최종적으로 사용하도록 설득하기를 바랍니다.


이것 좀 봐-꽤 무거운 것들 .. http://msdn.microsoft.com/en-us/magazine/cc164165.aspx

필수 .net-don 상자에는 차단이라는 장이 있습니다. 나는 여기에 그중 일부를 긁어 냈습니다 (글꼴 색상에 대해 죄송합니다-그때는 어두운 테마가있었습니다 ...) http://madcoderspeak.blogspot.com/2005/09/essential-interception-using-contexts.html


더 쉬운 다른 방법을 찾았습니다 ...

메소드 InvokeMethod 선언

[WebMethod]
    public object InvokeMethod(string methodName, Dictionary<string, object> methodArguments)
    {
        try
        {
            string lowerMethodName = '_' + methodName.ToLowerInvariant();
            List<object> tempParams = new List<object>();
            foreach (MethodInfo methodInfo in serviceMethods.Where(methodInfo => methodInfo.Name.ToLowerInvariant() == lowerMethodName))
            {
                ParameterInfo[] parameters = methodInfo.GetParameters();
                if (parameters.Length != methodArguments.Count()) continue;
                else foreach (ParameterInfo parameter in parameters)
                    {
                        object argument = null;
                        if (methodArguments.TryGetValue(parameter.Name, out argument))
                        {
                            if (parameter.ParameterType.IsValueType)
                            {
                                System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(parameter.ParameterType);
                                argument = tc.ConvertFrom(argument);

                            }
                            tempParams.Insert(parameter.Position, argument);

                        }
                        else goto ContinueLoop;
                    }

                foreach (object attribute in methodInfo.GetCustomAttributes(true))
                {
                    if (attribute is YourAttributeClass)
                    {
                        RequiresPermissionAttribute attrib = attribute as YourAttributeClass;
                        YourAttributeClass.YourMethod();//Mine throws an ex
                    }
                }

                return methodInfo.Invoke(this, tempParams.ToArray());
            ContinueLoop:
                continue;
            }
            return null;
        }
        catch
        {
            throw;
        }
    }

그런 다음 내 방법을 이렇게 정의하십시오.

[WebMethod]
    public void BroadcastMessage(string Message)
    {
        //MessageBus.GetInstance().SendAll("<span class='system'>Web Service Broadcast: <b>" + Message + "</b></span>");
        //return;
        InvokeMethod("BroadcastMessage", new Dictionary<string, object>() { {"Message", Message} });
    }

    [RequiresPermission("editUser")]
    void _BroadcastMessage(string Message)
    {
        MessageBus.GetInstance().SendAll("<span class='system'>Web Service Broadcast: <b>" + Message + "</b></span>");
        return;
    }

이제 종속성 주입없이 런타임에 확인할 수 있습니다 ...

사이트에 문제가 없습니다 :)

AOP 프레임 워크 나 MarshalByRefObject에서 파생되거나 원격 또는 프록시 클래스를 사용하는 것보다 가중치가 적다는 데 동의 할 것입니다.


먼저 MarshalByRefObject를 구현하는 대신 인터페이스를 구현하도록 클래스를 수정해야합니다.

interface ITraced {
    void Method1();
    void Method2()
}
class Traced: ITraced { .... }

다음으로 RealProxy 기반의 일반 래퍼 객체가 필요합니다. 데코 레이팅 된 객체에 대한 호출을 가로 챌 수 있도록 인터페이스를 장식하십시오.

class MethodLogInterceptor: RealProxy
{
     public MethodLogInterceptor(Type interfaceType, object decorated) 
         : base(interfaceType)
     {
          _decorated = decorated;
     }

    public override IMessage Invoke(IMessage msg)
    {
        var methodCall = msg as IMethodCallMessage;
        var methodInfo = methodCall.MethodBase;
        Console.WriteLine("Precall " + methodInfo.Name);
        var result = methodInfo.Invoke(_decorated, methodCall.InArgs);
        Console.WriteLine("Postcall " + methodInfo.Name);

        return new ReturnMessage(result, null, 0,
            methodCall.LogicalCallContext, methodCall);
    }
}

이제 ITraced의 Method1 및 Method2에 대한 호출을 가로 챌 준비가되었습니다.

 public class Caller 
 {
     public static void Call() 
     {
         ITraced traced = (ITraced)new MethodLogInterceptor(typeof(ITraced), new Traced()).GetTransparentProxy();
         traced.Method1();
         traced.Method2(); 
     }
 }

You can use open source framework CInject on CodePlex. You can write minimal code to create an Injector and get it to intercept any code quickly with CInject. Plus, since this is Open Source you can extend this as well.

Or you can follow the steps mentioned on this article on Intercepting Method Calls using IL and create your own interceptor using Reflection.Emit classes in C#.


I don't know a solution but my approach would be as follows.

Decorate the class (or its methods) with a custom attribute. Somewhere else in the program, let an initialization function reflect all types, read the methods decorated with the attributes and inject some IL code into the method. It might actually be more practical to replace the method by a stub that calls LogStart, the actual method and then LogEnd. Additionally, I don't know if you can change methods using reflection so it might be more practical to replace the whole type.


You could potentially use the GOF Decorator Pattern, and 'decorate' all classes that need tracing.

It's probably only really practical with an IOC container (but as pointer out earlier you may want to consider method interception if you're going to go down the IOC path).


you need to bug Ayende for an answer on how he did it: http://ayende.com/Blog/archive/2009/11/19/can-you-hack-this-out.aspx


AOP is a must for clean code implementing, however if you want to surround a block in C#, generic methods have relatively easier usage. (with intelli sense and strongly typed code) Certainly, it can NOT be an alternative for AOP.

Although PostSHarp have little buggy issues (i do not feel confident for using at production), it is a good stuff.

Generic wrapper class,

public class Wrapper
{
    public static Exception TryCatch(Action actionToWrap, Action<Exception> exceptionHandler = null)
    {
        Exception retval = null;
        try
        {
            actionToWrap();
        }
        catch (Exception exception)
        {
            retval = exception;
            if (exceptionHandler != null)
            {
                exceptionHandler(retval);
            }
        }
        return retval;
    }

    public static Exception LogOnError(Action actionToWrap, string errorMessage = "", Action<Exception> afterExceptionHandled = null)
    {
        return Wrapper.TryCatch(actionToWrap, (e) =>
        {
            if (afterExceptionHandled != null)
            {
                afterExceptionHandled(e);
            }
        });
    }
}

usage could be like this (with intelli sense of course)

var exception = Wrapper.LogOnError(() =>
{
  MessageBox.Show("test");
  throw new Exception("test");
}, "Hata");

  1. Write your own AOP library.
  2. Use reflection to generate a logging proxy over your instances (not sure if you can do it without changing some part of your existing code).
  3. Rewrite the assembly and inject your logging code (basically the same as 1).
  4. Host the CLR and add logging at this level (i think this is the hardest solution to implement, not sure if you have the required hooks in the CLR though).

The best you can do before C# 6 with 'nameof' released is to use slow StackTrace and linq Expressions.

E.g. for such method

    public void MyMethod(int age, string name)
    {
        log.DebugTrace(() => age, () => name);

        //do your stuff
    }

Such line may be produces in your log file

Method 'MyMethod' parameters age: 20 name: Mike

Here is the implementation:

    //TODO: replace with 'nameof' in C# 6
    public static void DebugTrace(this ILog log, params Expression<Func<object>>[] args)
    {
        #if DEBUG

        var method = (new StackTrace()).GetFrame(1).GetMethod();

        var parameters = new List<string>();

        foreach(var arg in args)
        {
            MemberExpression memberExpression = null;
            if (arg.Body is MemberExpression)
                memberExpression = (MemberExpression)arg.Body;

            if (arg.Body is UnaryExpression && ((UnaryExpression)arg.Body).Operand is MemberExpression)
                memberExpression = (MemberExpression)((UnaryExpression)arg.Body).Operand;

            parameters.Add(memberExpression == null ? "NA" : memberExpression.Member.Name + ": " + arg.Compile().DynamicInvoke().ToString());
        }

        log.Debug(string.Format("Method '{0}' parameters {1}", method.Name, string.Join(" ", parameters)));

        #endif
    }

참고URL : https://stackoverflow.com/questions/25803/how-do-i-intercept-a-method-call-in-c

반응형