Question

Possible Duplicate:
C# wrap method via attributes

I’d like to achieve such functionality:

[Atomic]
public void Foo()
{           
    /* foo logic */
}

Where [Atomic] attribute is an attribute, which wraps function logic within a transaction scope:

using(var scope = new TransactionScope())
{
    /* foo logic */
    scope.Complete();
}

How to write such an attribute?

I’ve asked before basically the same question, I know this can be done using AOP, but I didn’t mention I’m searching for some simplest proof of concept implementation or helpful articles which can help me to write this using pure .NET Framework (I suppose using RealProxy and MarshalByRefObject types, about which I’ve read browsing related questions).

I need to solve exactly this shown example. It seems like a basic thing so I want to learn how to do it starting from scratch. It doesn’t need to be safe and flexible for now.

Answer 1

It seems like a basic thing…

It’s one of the (many) things which are simple to understand the concept, but not at all simple to implement.

As per Oded’s answer, Attributes in .NET don’t do anything. They only exist so that other code (or developers) can look at them later on. Think of it as a fancy comment.

With that in mind, you can write your attribute like this

public class AtomicAttribute : Attribute { } 

Now the hard part, you have to write some code to scan for that attribute, and change the behaviour of the code.

Given that C# is a compiled language, and given the rules of the .NET CLR there are theoretically 3 ways to do this

1. Hook into the C# compiler, and make it output different code when it sees that attribute.
   This seems like it would be nice, but it is simply not possible
   right now. Perhaps the
   Roslyn
   project might allow this in future, but for now, you can’t do it.

2. Write something which will scan the .NET assembly after the C# compiler has converted it to MSIL, and change the MSIL.
   This is basically what PostSharp does. Scanning and rewriting MSIL is hard. There are libraries such as Mono.Cecil which can help, but it’s still a hugely difficult problem. It may also interfere with the debugger, etc.

3. Use the .NET Profiling API’s to monitor the program while it is running, and every time you see a function call with that attribute, redirect it to some other wrapper function.
   This is perhaps the simplest option (although it’s still very difficult), but the drawback is that your program now must be run under the profiler. This may be fine on your development PC, but it will cause a huge problem if you try deploy it. Also, there is likely to be a large performance hit using this approach.

In my opinion, your best bet is to create a wrapper function which sets up the transaction, and then pass it a lambda which does the actual work. Like this:

public static class Ext 
{
    public static void Atomic(Action action) 
    {
        using(var scope = new TransactionScope()) 
        {
            action();
            scope.Commit();
        }
    }
}

.....

using static Ext; // as of VS2015

public void Foo()
{
    Atomic(() => {
        // foo logic
    }
}

The fancy computer science term for this is Higher order programming