Click here to Skip to main content
Click here to Skip to main content

Tagged as

Go to top

Intercepting Console.WriteLine and Other Third-Party Method Calls with LinFu.AOP 2.0

, 4 May 2011
Rate this:
Please Sign up or sign in to vote.
Intercepting Console.WriteLine and Other Third-Party Method Calls with LinFu.AOP 2.0

ConsoleInterceptor

Worth a Thousand Words

In case you are wondering, yes, that is a screenshot of LinFu.AOP intercepting calls to Console.WriteLine() at runtime.

One of the more useful things that LinFu.AOP can do is intercept calls to third-party assemblies that aren't necessarily under your control. In fact, LinFu makes it so easy that all you have to do to make the interception happen is add the reference to LinFu like the following lines to your CSProj file just like I did with my SampleLibrary.csproj file:

<PropertyGroup>
  <PostWeaveTaskLocation>
    $(MSBuildProjectDirectory)\$(OutputPath)\..\..\..\lib\LinFu.Core.dll
  </PostWeaveTaskLocation>
</PropertyGroup>
<UsingTask TaskName="PostWeaveTask" AssemblyFile="$(PostWeaveTaskLocation)" />
<Target Name="AfterBuild">
  <PostWeaveTask TargetFile="$(MSBuildProjectDirectory)\
	$(OutputPath)$(MSBuildProjectName).dll" 
                 InterceptAllMethodCalls="true" />
</Target>

'Automagically' Delicious

Once you reload and rebuild the solution, LinFu.AOP will automatically modify your code after the build runs so that you can intercept it at runtime. LinFu does this by adding hooks to your code so you can change it as the program is running. In this case, I casted the modified BankAccount class to an IModifiableType instance so that I could add my custom ConsoleInterceptor instance:

// Create the BankAccount class just like normal...
var account = new BankAccount(100);
// Notice how LinFu.AOP automatically implements IModifiableType 
// so you can intercept/replace method calls at runtime
var modifiableType = account as IModifiableType;
if (modifiableType != null)
modifiableType.MethodCallReplacementProvider = new WriteLineMethodReplacementProvider();

account.Deposit(100);

The WriteLineMethodReplacementProvider class, in turn, determines the method calls that should be intercepted at runtime:

public class WriteLineMethodReplacementProvider : IMethodReplacementProvider
{
    public bool CanReplace(object host, IInvocationInfo info)
    {
        var declaringType = info.TargetMethod.DeclaringType;
        if (declaringType != typeof(System.Console))
        return false;

        // We're only interested in replacing Console.WriteLine()
        var targetMethod = info.TargetMethod;
        return targetMethod.Name == "WriteLine";
    }

    public IInterceptor GetMethodReplacement(object host, IInvocationInfo info)
    {
        return new ConsoleInterceptor();
    }
}

Choosing Which Methods to Intercept

As you can see from the example above, this class ensures that only calls to Console.WriteLine() are ever intercepted. The ConsoleInterceptor itself is responsible for replacing and intercepting the Console.WriteLine() method itself:

public class ConsoleInterceptor : IInterceptor
{
    public object Intercept(IInvocationInfo info)
    {
        var targetType = info.TargetMethod.DeclaringType;
        var target = info.Target;
        var targetMethod = info.TargetMethod;
        var arguments = info.Arguments;

        Console.WriteLine("Intercepted method named '{0}'", targetMethod.Name);

        // Call the original WriteLine method
        targetMethod.Invoke(null, arguments);

        // Console.WriteLine doesn't have a return value so it's OK to return null)
        return null;
    }
}

The most interesting part about the code example is how LinFu.AOP adds the method call hooks without touching a single line of the source code. All of the IL rewriting is done behind the scenes so you won't have to worry about the gory details of using an AOP framework in your legacy code. The beauty of this approach is that it allows you to intercept any method call, even if that method call is a part of the .NET base class libraries.

You can find the LinFu.AOP.Examples library here at Github.

Note: Please intercept BCL method calls responsibly.

License

This article, along with any associated source code and files, is licensed under The GNU Lesser General Public License (LGPLv3)

Share

About the Author

Philip Laureano
Software Developer (Senior) Readify
Australia Australia
No Biography provided
Follow on   Twitter

Comments and Discussions

 
Questionthis post is useless with EF code first Pinmemberron0123423-Jul-13 20:08 
QuestionQuestion Pinmemberron0123422-Jul-13 13:54 
GeneralSomething is missing? Pinmembercaloggins9-May-11 7:57 
GeneralRe: Something is missing? PinmemberPhilip Laureano9-May-11 14:00 
JokeRe: Something is missing? Pinmembercaloggins10-May-11 0:42 
GeneralRe: Something is missing? Pinmemberron0123423-Jul-13 13:11 
GeneralGood stuff PinmemberRugbyLeague4-May-11 3:24 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Mobile
Web01 | 2.8.140916.1 | Last Updated 4 May 2011
Article Copyright 2011 by Philip Laureano
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid