Are C# Attributes the Same Thing as Python-TypeScript Decorators?

Preface

Recently I successfully dragged Frontend Mentor into the C# pit (actually Frontend Mentor started switching from cocos to unity game development)

One day, Frontend Mentor saw this code and asked a question: [is this a decorator]?

[HttpGet]
public Response Get() {
    return ...
}

My first reaction was that it isn’t. This thing is called an “attribute” in C# (English name Attribute, hereafter referred to as attributes), and an annotation in Java. Although the syntax is similar to that in Python/TypeScript, I had the impression that the implementation should be different.

But those of us trained in science and engineering have to be rigorous and can’t rely on experience and gut feeling alone. For that reason, I looked up some materials and read the book C# in nutshell that expert Yang Xu had recommended before. I not only confirmed the answer to this question, but also learned more about Attributes.

About AOP

“Attributes” and decorators are actually both the decorator pattern in design patterns, and also the idea of AOP.

AOP is Aspect Oriented Programming, that is, aspect-oriented programming.

AOP decomposes a system into different concerns, or what are called aspects (Aspect). It is a programming idea of dynamically weaving code into specified methods and specified locations of a class at runtime

For example, suppose there is a website with shopping, social, gaming, and other features, all open to every user. Now we need to restrict a few of those features so that only premium members can use them. We could add if checks in every module, but that would be too invasive and would create a lot of duplicated code. Switching to the AOP approach means using decorators: just add the restriction where premium membership is required~

Specific Differences

First let’s look at the differences in syntax

Python Decorators

First let’s look at decorators in Python. In Python, functions are first-class citizens, and a decorator is also a function that nests another function inside it

def outer(func):
    def inner():
        # ... 一些代码
        result = func()
        return result
    return inner

When using it

@outer
def test():
    print('test')

The usage syntax is the same as Java annotations, starting with @

This is actually syntactic sugar; the actual effect is equivalent to

outer(test)

The test function is passed as an argument to the decorator. After that, the execution order of this code is as follows:

• def outer(func): decorator definition
• @outer: decorator syntactic sugar, directly executes the outer function, passing the test function as an argument
• outer: executes the decorator syntax rules, replacing the test function with the inner function
• inner: executes the inner function code
• test: according to this line of code in inner: result = func(), executes the test function code
• return

In a dynamic language like Python, implementing the decorator pattern is indeed easier than in static languages. The decorated content is passed as an argument to the decorator, and the decorator can directly access the decorated content to do some processing.

C# “Attributes”

In C#, an “attribute” is a class that inherits from the Attribute class, and can then contain any property fields you want

Decorated with the AttributeUsage attribute, you can specify which code elements this attribute can decorate

[AttributeUsage(AttributeTargets.Class |
AttributeTargets.Constructor |
AttributeTargets.Field |
AttributeTargets.Method |
AttributeTargets.Property,
AllowMultiple = true)]
public class DemoAttribute : Attribute {
    public DemoAttribute(string param1) {
        this.param1 = param1;
    }
    
    public string param1 { get; set; }
}

The parameters in the constructor are the parameters passed in when using the attribute, for example like this:

[DemoAttribute("class")]
public class DemoClass {
    [Demo("method")]
    public void Method1() {
    }
}

PS: When using an attribute you can omit the trailing "Attribute", so DemoAttribute and Demo are the same thing

Writing it this way doesn’t produce any effect

Because attributes are merely decoration

When the code runs, the C# compiler first instantiates the DemoAttribute class, then instantiates the DemoClass class, and inside DemoAttribute you cannot obtain the decorated content.

To make the decoration take effect, you need to use it together with reflection~

Reflection refers to a program’s ability to access, inspect, and modify its own state or behavior.

With the following code you can obtain the attributes decorating DemoClass

var info = typeof(DemoClass);
var attributes = info.GetCustomAttributes(true);

With the following code you can obtain the decorated methods, the decoration parameters, and so on

foreach (var methodInfo in typeof(DemoClass).GetMethods()) {
    var attribute = (DemoAttribute) Attribute.GetCustomAttribute(methodInfo, typeof(DemoAttribute));
    if (attribute != null)
        Console.WriteLine("方法 {0} 被装饰，装饰参数 {1}", methodInfo.Name, attribute.param1);
}

After obtaining this information, you then do some further processing with other capabilities provided by reflection, and that implements so-called AOP

Summary

So, although C# attributes and Python/TypeScript decorators differ in syntax and usage, they arrive at the same destination by different paths; the purpose they aim to achieve is indeed similar.

But it wouldn’t be rigorous to say they are the same thing, so they shouldn’t be considered the same thing; rather, they are each language’s way of implementing AOP.

References

• A Comparison of C# Attributes and TypeScript Decorators: https://blog.csdn.net/weixin_43263355/article/details/110137016
• How to Implement Python-like Decorators in C#: https://www.zhihu.com/question/36211661
• AOP Aspect-Oriented Programming: https://bbs.huaweicloud.com/blogs/289045