Bagian 1: Pendahuluan

Dalam pengembangan aplikasi C#, kode seperti berikut cukup sering ditemui:

[HttpGet]
public IActionResult GetUsers() { ... }

Sekilas, [HttpGet] terlihat seperti informasi tambahan yang ditempatkan di atas method. Namun, bagaimana ASP.NET Core bisa mengetahui bahwa method tersebut harus menangani HTTP GET?

Method tersebut tidak memanggil fungsi khusus untuk mendaftarkan dirinya sebagai handler GET. Tidak ada logic di dalam method yang secara eksplisit menyatakan hal tersebut. Informasinya hanya ditulis dalam bentuk [HttpGet], lalu ASP.NET Core dapat membacanya dan menggunakannya.

Hal serupa juga dapat ditemukan di berbagai bagian lain dalam ekosistem .NET:

• Bagaimana sebuah class dapat memiliki informasi tambahan tanpa perlu menambahkan property baru?

• Bagaimana Entity Framework dapat mengetahui bahwa sebuah property merupakan primary key hanya dengan menambahkan [Key]?

• Bagaimana JsonSerializer dapat mengetahui bahwa property FirstName perlu ditulis sebagai first_name dalam JSON?

Pertanyaan-pertanyaan tersebut memiliki satu konsep yang sama sebagai dasar jawabannya: metadata.

Apa itu Metadata?

Secara sederhana, metadata adalah informasi tentang sesuatu. Dalam konteks pemrograman, metadata dapat berupa informasi tambahan mengenai kode, seperti class, method, property, parameter, atau elemen program lainnya.

Metadata bukan merupakan logic utama dari program. Namun, informasi tersebut dapat dibaca dan dimanfaatkan oleh berbagai komponen, seperti compiler, tooling, library, maupun framework.

Misalnya, kode berikut:

[HttpGet]
public IActionResult GetUsers() { ... }

GetUsers() berisi logic untuk menangani suatu proses. Sementara itu, [HttpGet] memberikan informasi tambahan mengenai bagaimana method tersebut seharusnya digunakan oleh ASP.NET Core.

Dengan kata lain, [HttpGet] tidak menjalankan proses HTTP GET secara langsung. Attribute tersebut memberikan informasi yang nantinya dapat dibaca oleh ASP.NET Core.

Attribute sebagai Salah Satu Cara Menambahkan Metadata

Salah satu cara yang umum digunakan untuk menambahkan metadata di C# adalah melalui Attribute. Bentuknya biasanya mudah dikenali karena menggunakan tanda kurung siku:

[HttpGet]
[Obsolete]
[Serializable]

Attribute dapat ditempatkan pada berbagai bagian kode, misalnya class, method, property, parameter, dan beberapa elemen program lainnya.

Contohnya:

[Obsolete]
public void OldMethod()
{
}

Pada contoh tersebut, [Obsolete] memberikan informasi tambahan bahwa OldMethod() sudah tidak dianjurkan untuk digunakan.

Contoh lain dapat ditemukan pada ASP.NET Core:

[HttpGet]
public IActionResult GetUsers()
{
    // ...
}

[HttpGet] memberikan metadata kepada ASP.NET Core bahwa method tersebut berkaitan dengan HTTP GET.

Hal penting yang perlu dipahami adalah bahwa Attribute bukan sekadar "teks yang ditempel" di atas kode. Di balik sintaks tersebut terdapat sebuah object yang dapat dibaca melalui mekanisme tertentu di .NET.

Mengapa Attribute Penting?

Attribute digunakan di banyak bagian dalam ekosistem .NET. Beberapa framework dan library memanfaatkannya untuk memberikan informasi tambahan pada kode.

Contohnya:

• ASP.NET Core menggunakan Attribute untuk routing, authorization, filtering, dan berbagai kebutuhan lainnya.

• Entity Framework Core dapat menggunakan Attribute seperti [Key] dan [Required] untuk memberikan konfigurasi pada model.

• System.Text.Json menyediakan Attribute seperti [JsonPropertyName] untuk mengatur proses serialisasi dan deserialisasi JSON.

• xUnit menggunakan Attribute seperti [Fact] untuk menandai method sebagai test.

• .NET compiler juga mengenali Attribute tertentu, seperti [Obsolete], dan dapat memberikan warning ketika Attribute tersebut digunakan.

Karena itu, memahami Attribute tidak hanya membantu memahami sintaks [Something] yang sering terlihat dalam kode C#. Lebih jauh lagi, konsep ini dapat membantu menjelaskan bagaimana framework dapat membaca informasi dari kode dan mengambil keputusan berdasarkan informasi tersebut.

Artikel ini akan membahas Attribute secara bertahap. Pembahasan dimulai dari konsep dasar Attribute, cara membuat Custom Attribute, hingga bagaimana Attribute dibaca menggunakan Reflection. Setelah itu, pembahasan akan dilanjutkan dengan melihat bagaimana konsep yang sama digunakan oleh berbagai framework besar di ekosistem .NET.

Bagian 2: Apa Itu Attribute?

Secara sederhana, Attribute adalah mekanisme di C# untuk menambahkan metadata pada elemen kode, seperti class, method, property, parameter, atau bahkan assembly secara keseluruhan.

Metadata dapat dipahami sebagai informasi tentang kode. Informasi ini memberikan keterangan tambahan mengenai suatu elemen kode tanpa menjadi bagian dari logic utama elemen tersebut.

Sebagai gambaran sederhana, sebuah buku memiliki isi yang menjadi bagian utama buku tersebut. Di luar isi tersebut, terdapat informasi lain seperti judul, penulis, dan tahun terbit.

Buku
├── Isi
├── Judul
├── Penulis
└── Tahun terbit

Judul, penulis, dan tahun terbit tidak mengubah isi buku. Namun, informasi tersebut memberikan konteks tambahan mengenai buku. Konsep yang kurang lebih sama dapat ditemukan pada kode:

Class / Method
├── Logic
└── Metadata
    └── Attribute

Logic menentukan apa yang dilakukan oleh kode, sedangkan Attribute memberikan informasi tambahan mengenai kode tersebut.

Contohnya:

[Obsolete]
public void OldMethod()
{
    // ...
}

OldMethod() tetap memiliki logic yang sama. [Obsolete] tidak mengubah isi method tersebut, tetapi memberikan informasi bahwa method tersebut sudah tidak dianjurkan untuk digunakan.

Attribute Disimpan sebagai Metadata

Ketika project C# dikompilasi, informasi mengenai Attribute akan menjadi bagian dari metadata assembly. Metadata tersebut kemudian dapat dibaca kembali oleh berbagai mekanisme di .NET, termasuk saat aplikasi sedang berjalan.

Inilah salah satu alasan mengapa sebuah program dapat mengetahui bahwa suatu method memiliki Attribute tertentu meskipun informasi tersebut tidak ditulis sebagai property atau field biasa di dalam class.

Sebagai contoh:

[Obsolete]
public void OldMethod()
{
}

Setelah program dikompilasi, informasi mengenai [Obsolete] tetap tersedia dalam metadata assembly. Kode lain dapat membaca informasi tersebut ketika diperlukan. Salah satu mekanisme yang paling umum digunakan untuk membaca informasi semacam ini adalah Reflection. Reflection akan dibahas lebih lanjut pada bagian berikutnya.

Attribute Bukan Logic Program

Attribute juga perlu dibedakan dari logic program.

Misalnya:

[Obsolete]
public void OldMethod()
{
    Console.WriteLine("Hello");
}

[Obsolete] tidak membuat OldMethod() menjalankan instruksi tambahan ketika method tersebut dipanggil. Attribute hanya memberikan informasi tambahan mengenai method tersebut. Hal yang sama berlaku untuk banyak Attribute lainnya. Attribute pada dasarnya berisi informasi yang dapat digunakan oleh sistem lain.

Attribute Bersifat Pasif

Attribute tidak melakukan sesuatu dengan sendirinya.

Sebagai contoh:

[HttpGet]
public IActionResult GetUsers()
{
    // ...
}

Menambahkan [HttpGet] tidak secara langsung membuat method tersebut menerima HTTP GET request.

ASP.NET Core memiliki mekanisme sendiri untuk menemukan endpoint, membaca Attribute yang terdapat pada method tersebut, lalu menggunakan informasi tersebut untuk menentukan bagaimana endpoint tersebut harus diperlakukan.

Jadi, ada beberapa bagian yang perlu dibedakan:

[HttpGet]
    │
    ▼
Metadata
    │
    ▼
Dibaca oleh mekanisme ASP.NET Core
    │
    ▼
Digunakan untuk menentukan routing

Attribute menyediakan informasinya. Kode lain yang membaca informasi tersebutlah yang menentukan bagaimana informasi itu digunakan.

Attribute sebagai Wadah Informasi

Karena itu, Attribute dapat dipandang sebagai wadah informasi tambahan yang ditempelkan pada kode.

Misalnya:

[HttpGet]
public IActionResult GetUsers()
{
    // ...
}

Secara sederhana, dapat dibayangkan bahwa method tersebut memiliki informasi tambahan seperti:

Method: GetUsers
Metadata:
    HTTP Method = GET

Kemudian, framework yang membutuhkan informasi tersebut dapat membacanya dan mengambil keputusan berdasarkan metadata tersebut.

Cara pembacaan dan pemanfaatannya dapat berbeda-beda tergantung pada framework atau library yang digunakan. Pada banyak kasus, Reflection menjadi salah satu mekanisme penting yang memungkinkan informasi tersebut ditemukan saat runtime.

Dengan cara pandang ini, Attribute dapat dianggap sebagai label yang membawa informasi tambahan tentang kode. Label tersebut tidak menjalankan logic utama program, tetapi dapat menjadi sangat berguna ketika ada bagian lain dari aplikasi yang membacanya dan mengetahui cara memanfaatkannya.

Bagian 3: Kenapa Attribute Dibutuhkan?

Setelah memahami apa itu Attribute, muncul pertanyaan yang cukup wajar: mengapa perlu menggunakan Attribute? Bukankah informasi yang sama sebenarnya bisa disimpan atau ditentukan menggunakan logic biasa?

Secara teknis, memang bisa. Namun, Attribute memberikan cara yang lebih jelas untuk menyatakan informasi tentang kode tanpa mencampurkannya dengan logic yang menjalankan proses.

Contoh Sederhana

Misalnya, sebuah framework perlu mengetahui property mana yang digunakan sebagai primary key. Salah satu pendekatan yang mungkin digunakan tanpa Attribute adalah membuat konvensi berdasarkan nama property:

if (property.Name == "Id")
{
    // Anggap property ini sebagai primary key
}

Selama semua class menggunakan property bernama Id, pendekatan tersebut dapat berjalan dengan baik. Namun, pendekatan seperti ini memiliki keterbatasan. Bagaimana jika sebuah class menggunakan nama UserId?

public class User
{
    public int UserId { get; set; }
}

Logic sebelumnya tidak akan mengenali UserId sebagai primary key karena hanya mencari property dengan nama Id. Masalah lainnya adalah informasi penting menjadi tersembunyi di dalam logic.

Ketika melihat class tersebut:

public class User
{
    public int UserId { get; set; }
}

Tidak ada informasi yang secara langsung menunjukkan bahwa UserId memiliki peran khusus. Untuk mengetahuinya, perlu mencari kode lain yang memproses class tersebut.

Menyatakan Informasi Secara Eksplisit

Attribute memberikan pendekatan yang berbeda.

Sebagai ilustrasi:

public class User
{
    [PrimaryKey]
    public int UserId { get; set; }
}

Sekarang informasi mengenai primary key berada langsung pada property yang bersangkutan.

Ketika melihat UserId, dapat langsung terlihat bahwa property tersebut memiliki peran khusus:

UserId
  │
  └── [PrimaryKey]
          │
          └── Property ini adalah primary key

Tidak perlu mengetahui bagaimana framework memproses property tersebut terlebih dahulu untuk memahami maksud deklarasinya. Inilah salah satu kekuatan utama Attribute: informasi dapat dinyatakan secara deklaratif di tempat informasi tersebut berlaku.

Beberapa Keuntungan Attribute

1. Lebih mudah dibaca

Attribute membuat metadata terlihat langsung pada elemen kode yang berkaitan.

Misalnya:

[Required]
public string Name { get; set; }

Informasi bahwa Name wajib diisi dapat terlihat langsung dari deklarasinya.

Bandingkan dengan aturan yang hanya terdapat di tempat lain:

if (property.Name == "Name")
{
    // ...
}

Pembaca kode perlu mengetahui terlebih dahulu bahwa terdapat logic tertentu yang memperlakukan Name secara khusus.

Dengan Attribute, informasi tersebut lebih dekat dengan sumbernya.

2. Tidak bergantung pada nama

Attribute memungkinkan suatu elemen kode memiliki peran tertentu tanpa harus mengikuti nama tertentu.

Misalnya:

[PrimaryKey]
public int UserId { get; set; }

Primary key tidak harus bernama Id. Nama UserId, CustomerNumber, atau nama lainnya tetap dapat digunakan selama mekanisme yang membaca Attribute memahami [PrimaryKey].

Dengan demikian, nama dan peran dapat dipisahkan.

3. Lebih mudah dipelihara

Ketika aturan perlu diubah, Attribute dapat menjadi tempat yang jelas untuk menyatakan perubahan tersebut.

Misalnya:

[Required]
public string Email { get; set; }

Kemudian aturan validasi berubah dan property tersebut tidak lagi wajib diisi. Perubahannya dapat dilakukan pada deklarasi metadata tersebut, tanpa harus mencari berbagai logic yang mungkin bergantung pada nama property. Tentu saja, tingkat kemudahannya tetap bergantung pada bagaimana framework atau aplikasi dirancang.

4. Mengurangi ketergantungan pada konvensi tersembunyi

Konvensi penamaan sebenarnya bukan sesuatu yang buruk. Banyak framework justru menggunakan convention over configuration untuk mengurangi konfigurasi yang tidak perlu.

Misalnya, framework dapat memiliki aturan:

Property bernama "Id"
        ↓
Dianggap sebagai primary key

Pendekatan ini sederhana dan nyaman selama konvensinya cukup jelas dan tidak perlu banyak pengecualian. Masalah mulai muncul ketika aturan menjadi semakin kompleks atau tidak lagi dapat diwakili hanya dengan nama.

Attribute dapat digunakan ketika informasi tersebut perlu dinyatakan secara lebih eksplisit:

[PrimaryKey]
    ↓
Property ini adalah primary key

Dengan demikian, Attribute dan convention sebenarnya bukan dua pendekatan yang harus selalu dipertentangkan. Convention cocok untuk aturan umum yang sederhana, sedangkan Attribute berguna ketika suatu informasi perlu dinyatakan secara eksplisit pada elemen kode tertentu.

Attribute dan Pendekatan Deklaratif

Di sinilah konsep deklaratif menjadi penting. Dengan pendekatan imperatif, kode menjelaskan bagaimana suatu proses dilakukan:

if (property.Name == "Id")
{
    // lakukan sesuatu
}

Sementara itu, Attribute dapat digunakan untuk menyatakan apa arti atau karakteristik dari suatu elemen:

[PrimaryKey]
public int UserId { get; set; }

Attribute tidak menjelaskan bagaimana primary key tersebut diproses. Attribute hanya menyatakan bahwa property tersebut memiliki karakteristik tertentu. Bagian lain dari sistem kemudian dapat membaca informasi tersebut dan menentukan apa yang harus dilakukan.

Gambaran sederhananya:

Attribute
    │
    │ menyatakan informasi
    ▼
[PrimaryKey]
public int UserId { get; set; }
    │
    │ dibaca oleh framework
    ▼
Framework menentukan perilaku

Pola seperti ini banyak digunakan oleh framework di ekosistem .NET. Developer cukup memberikan informasi yang diperlukan melalui deklarasi Attribute, sedangkan framework menangani proses di belakangnya.

Karena itu, Attribute bukan sekadar cara untuk menambahkan sintaks [Something] pada kode. Attribute merupakan salah satu cara untuk memisahkan informasi tentang kode dari logic yang menjalankan kode tersebut, sekaligus membuat informasi tersebut dapat dibaca oleh sistem lain.

Bagian 4: Anatomi dari sebuah Attribute

Setelah memahami apa itu Attribute dan alasan penggunaannya, bagian ini akan melihat bentuk Attribute secara lebih dekat.

Beberapa contoh Attribute yang mungkin sudah sering ditemui:

[Obsolete]
public void OldMethod() { }

[Serializable]
public class UserData { }

[AttributeUsage(AttributeTargets.Class)]
public class MyCustomAttribute : Attribute { }

[HttpGet]
public IActionResult Index() { }

Sekilas, semuanya terlihat memiliki pola yang sama:

[Attribute]
    ↓
Elemen kode

Nama Attribute ditulis di dalam tanda kurung siku [ ], kemudian ditempatkan pada elemen kode yang ingin diberi metadata. Tanda kurung siku tersebut merupakan syntax khusus C# untuk Attribute. Compiler mengenalinya sebagai deklarasi metadata, bukan sebagai statement biasa yang dieksekusi seperti pemanggilan method atau operasi if. Metadata tersebut kemudian menjadi bagian dari informasi yang tersedia pada hasil kompilasi dan dapat dibaca oleh komponen lain, termasuk saat aplikasi berjalan.

Attribute Sebenarnya Adalah Sebuah Class

Ada satu hal yang mungkin terlihat sedikit membingungkan ketika pertama kali mempelajari Attribute.

Misalnya terdapat kode:

[Obsolete]
public void OldMethod()
{
}

Dari syntax tersebut terlihat seolah-olah Obsolete adalah sesuatu yang khusus disediakan oleh compiler.

Sebenarnya, Obsolete adalah sebuah Attribute class yang bernama:

ObsoleteAttribute

Secara konsep, bentuk sederhananya dapat dibayangkan seperti:

public class ObsoleteAttribute : Attribute
{
    // ...
}

Jadi, Attribute yang ditulis menggunakan:

[Obsolete]

sebenarnya merujuk pada class ObsoleteAttribute.

Hal yang sama berlaku untuk Custom Attribute. Misalnya:

public class PrimaryKeyAttribute : Attribute
{
}

Attribute tersebut dapat digunakan seperti:

[PrimaryKey]
public int UserId { get; set; }

Dengan kata lain, syntax [PrimaryKey] sebenarnya merupakan cara khusus C# untuk menggunakan sebuah class Attribute.

Akhiran Attribute Boleh Dihilangkan

C# menyediakan kemudahan dalam penamaan Attribute. Jika nama class Attribute diakhiri dengan Attribute, akhiran tersebut boleh dihilangkan ketika Attribute digunakan.

Misalnya:

[Obsolete]

dan:

[ObsoleteAttribute]

keduanya merujuk pada ObsoleteAttribute.

Hal yang sama berlaku pada Custom Attribute:

public class PrimaryKeyAttribute : Attribute
{
}

Attribute tersebut dapat digunakan dengan:

[PrimaryKey]

atau:

[PrimaryKeyAttribute]

Keduanya valid.

Secara sederhana, dapat dibayangkan bahwa ketika compiler menemukan:

[PrimaryKey]

compiler dapat mencocokkannya dengan class:

PrimaryKeyAttribute

jika class tersebut tersedia dan memenuhi aturan Attribute.

Akhiran Attribute dapat dihilangkan hanya ketika digunakan dalam syntax Attribute. Nama class-nya sendiri tetap PrimaryKeyAttribute.

Kenapa Konvensi Ini Ada?

Konvensi tersebut terutama dibuat untuk membuat kode lebih ringkas dan mudah dibaca.

Bandingkan:

[HttpGet]
[Authorize]
[Obsolete]

dengan:

[HttpGetAttribute]
[AuthorizeAttribute]
[ObsoleteAttribute]

Keduanya valid jika class Attribute yang sesuai tersedia, tetapi bentuk pertama biasanya lebih nyaman dibaca. Konvensi ini berlaku baik untuk Attribute bawaan .NET maupun Custom Attribute yang dibuat dalam aplikasi sendiri.

Attribute Harus Berasal dari System.Attribute

Agar sebuah class dapat digunakan sebagai Attribute, class tersebut harus mewarisi System.Attribute, baik secara langsung maupun melalui inheritance.

Contoh paling sederhana:

public class PrimaryKeyAttribute : Attribute
{
}

Setelah itu, Attribute tersebut dapat digunakan:

public class User
{
    [PrimaryKey]
    public int UserId { get; set; }
}

Strukturnya dapat digambarkan seperti ini:

System.Attribute
       │
       ▼
PrimaryKeyAttribute
       │
       ▼
[PrimaryKey]

Di sini terlihat bahwa Attribute sebenarnya bukan jenis object yang sepenuhnya berbeda dari class biasa. Attribute adalah class yang mengikuti aturan khusus agar dapat digunakan sebagai metadata. Karena itu, memahami inheritance dari System.Attribute menjadi langkah penting sebelum mulai membuat Custom Attribute.

Bagian 5: Attribute Adalah Class

Salah satu konsep penting sebelum membuat Custom Attribute adalah memahami bahwa Attribute pada dasarnya adalah sebuah class. Tidak ada mekanisme khusus yang membuat [Obsolete] atau [Serializable] menjadi sesuatu yang sepenuhnya berbeda dari konsep class dalam C#. Keduanya berasal dari class yang mewarisi System.Attribute.

Sebagai gambaran sederhana:

public class ObsoleteAttribute : Attribute
{
    public string Message { get; }

    public ObsoleteAttribute(string message)
    {
        Message = message;
    }
}

Kemudian Attribute tersebut dapat digunakan seperti:

[Obsolete("Gunakan method versi baru")]
public void OldMethod()
{
}

Di sini ObsoleteAttribute adalah sebuah class, sedangkan [Obsolete(...)] adalah syntax Attribute yang digunakan untuk memberikan metadata pada OldMethod().

Inheritance dari System.Attribute

Setiap class yang dimaksudkan untuk digunakan sebagai Attribute harus mewarisi System.Attribute, baik secara langsung maupun melalui class turunan lainnya. Secara sederhana, hubungan inheritance-nya dapat digambarkan seperti ini:

System.Attribute
       │
       ├── ObsoleteAttribute
       ├── SerializableAttribute
       │
       └── AuthorAttribute

Contoh sederhananya:

// Class dasar dari .NET
public abstract class Attribute
{
}

// Attribute bawaan
public class ObsoleteAttribute : Attribute
{
}

public class SerializableAttribute : Attribute
{
}

// Custom Attribute
public class AuthorAttribute : Attribute
{
}

Dengan mewarisi System.Attribute, sebuah class dapat dikenali sebagai class yang dapat digunakan dalam syntax Attribute.

Attribute Tetap Mengikuti Konsep Class

Karena Attribute merupakan class, konsep OOP yang umum juga dapat ditemukan di dalamnya. Sebuah Attribute dapat memiliki:

• constructor

• property

• field

• method

Contohnya:

public class AuthorAttribute : Attribute
{
    public string Name { get; }

    public AuthorAttribute(string name)
    {
        Name = name;
    }
}

Attribute tersebut kemudian dapat digunakan:

[Author("Budi")]
public class UserService
{
}

String "Budi" pada contoh tersebut bukan sekadar teks yang ditempelkan pada class. Nilai tersebut merupakan argumen yang diberikan kepada constructor AuthorAttribute.

Secara konsep, deklarasi:

[Author("Budi")]

berhubungan dengan:

new AuthorAttribute("Budi")

Namun, keduanya tidak digunakan dengan cara yang sama. new AuthorAttribute("Budi") adalah pembuatan object secara langsung dalam logic program, sedangkan [Author("Budi")] adalah deklarasi metadata pada kode.

Lalu Apa yang Terjadi Saat Compile?

Bagian ini perlu sedikit diperhatikan karena terdapat perbedaan antara source code, metadata assembly, dan object Attribute saat runtime.

Ketika compiler menemukan:

[Author("Budi")]
public class UserService
{
}

compiler tidak sekadar menganggapnya sebagai pemanggilan constructor biasa.

Compiler memproses deklarasi tersebut dan menyimpan informasi Attribute ke dalam metadata hasil kompilasi, termasuk informasi mengenai:

• Attribute class yang digunakan

• constructor yang digunakan

• argumen yang diberikan

• target tempat Attribute tersebut dipasang

Informasi tersebut menjadi bagian dari assembly dan dapat dibaca kembali nantinya.

Jadi, secara sederhana:

Source Code
     │
     │ compile
     ▼
Assembly
     │
     ├── IL
     ├── Type information
     └── Attribute metadata

Pada tahap ini, lebih tepat membayangkan bahwa informasi untuk Attribute disimpan dalam metadata assembly, bukan bahwa object Attribute sudah dibuat dan disimpan sebagai object hidup di dalam assembly.

Kapan Object Attribute Dibuat?

Object Attribute dapat dibuat ketika metadata tersebut dibaca kembali, misalnya menggunakan Reflection.

Misalnya terdapat:

[Author("Budi")]
public class UserService
{
}

Kemudian kode lain menggunakan Reflection untuk mengambil Attribute:

var attribute = typeof(UserService)
    .GetCustomAttributes(typeof(AuthorAttribute), inherit: false)
    .FirstOrDefault();

Pada proses tersebut, .NET dapat membuat instance AuthorAttribute berdasarkan informasi yang tersimpan di metadata.

Hasilnya dapat digunakan seperti object biasa:

if (attribute is AuthorAttribute author)
{
    Console.WriteLine(author.Name);
}

Secara sederhana, alurnya menjadi:

[Author("Budi")]
       │
       │ compile
       ▼
Metadata dalam Assembly
       │
       │ Reflection
       ▼
AuthorAttribute instance
       │
       ▼
author.Name
       │
       ▼
"Budi"

Di sinilah konsep Attribute mulai terlihat lebih jelas. Syntax [Author("Budi")] memang terlihat sederhana, tetapi di baliknya terdapat beberapa tahap: compiler menyimpan informasi tersebut ke dalam metadata, kemudian runtime dapat membaca metadata tersebut dan membuat instance Attribute ketika diperlukan.

Dengan memahami hal ini, syntax seperti:

[Obsolete("Gunakan CalculateV2()")]

tidak lagi terlihat seperti sesuatu yang misterius.

Terdapat sebuah class bernama ObsoleteAttribute, terdapat constructor yang menerima parameter, dan informasi mengenai penggunaan Attribute tersebut disimpan sebagai metadata dalam assembly. Reflection kemudian menjadi salah satu mekanisme yang memungkinkan metadata tersebut dibaca kembali saat runtime.

Bagian 6: Attribute Bawaan .NET

Sebelum membuat Custom Attribute sendiri, ada baiknya melihat beberapa Attribute yang sudah tersedia di .NET. Attribute-Attribute ini dapat ditemukan di berbagai jenis aplikasi dan library. Masing-masing memiliki tujuan yang berbeda, tetapi pola dasarnya tetap sama: memberikan informasi tambahan pada elemen kode yang kemudian digunakan oleh compiler, runtime, atau library tertentu.

Obsolete

[Obsolete]
public void OldMethod()
{
}

ObsoleteAttribute digunakan untuk menandai suatu elemen kode sebagai sudah tidak dianjurkan untuk digunakan.

Misalnya:

[Obsolete]
public void OldMethod()
{
}

public void NewMethod()
{
}

Ketika OldMethod() digunakan dari kode lain, compiler dapat memberikan warning bahwa method tersebut sudah tidak digunakan lagi.

Pesan yang lebih informatif juga dapat diberikan:

[Obsolete("Gunakan NewMethod() sebagai gantinya.")]
public void OldMethod()
{
}

Bahkan, Attribute ini dapat dikonfigurasi agar penggunaannya menghasilkan error:

[Obsolete("Gunakan NewMethod() sebagai gantinya.", true)]
public void OldMethod()
{
}

Dalam contoh tersebut, true menunjukkan bahwa penggunaan OldMethod() harus dianggap sebagai error oleh compiler. Menariknya, Obsolete merupakan contoh Attribute yang diproses oleh compiler. Artinya, efeknya dapat terlihat bahkan sebelum aplikasi dijalankan.

Serializable

[Serializable]
public class UserData
{
}

SerializableAttribute digunakan untuk menandai sebuah class sebagai dapat diserialisasi oleh mekanisme tertentu yang mendukung Attribute tersebut. Attribute ini terutama berkaitan dengan mekanisme serialisasi lama di .NET, termasuk BinaryFormatter.

Perlu diperhatikan bahwa [Serializable] bukan berarti object tersebut otomatis berubah menjadi JSON, XML, atau format tertentu hanya karena Attribute tersebut ditambahkan. Attribute ini hanya memberikan metadata bahwa type tersebut mendukung mekanisme serialisasi tertentu.

Pada .NET modern, BinaryFormatter sendiri sudah tidak direkomendasikan untuk digunakan karena memiliki masalah keamanan. Karena itu, contoh [Serializable] lebih tepat dipahami sebagai bagian penting dari sejarah dan mekanisme serialisasi klasik .NET, bukan sebagai pendekatan yang biasanya dipilih untuk serialisasi data pada aplikasi baru.

Conditional

[Conditional("DEBUG")]
public void LogDebugInfo()
{
}

ConditionalAttribute memiliki perilaku yang cukup berbeda dibanding Attribute seperti Obsolete. Attribute ini dapat digunakan untuk menentukan apakah pemanggilan sebuah method akan disertakan oleh compiler berdasarkan apakah suatu conditional compilation symbol tersedia.

Contohnya:

[Conditional("DEBUG")]
public void LogDebugInfo()
{
    Console.WriteLine("Debug information");
}

Kemudian:

LogDebugInfo();

Jika symbol DEBUG tersedia, pemanggilan method tersebut akan dipertahankan dalam hasil kompilasi. Jika DEBUG tidak tersedia, pemanggilan tersebut dapat dihilangkan oleh compiler. Hal penting yang perlu diperhatikan adalah bahwa ConditionalAttribute berlaku pada pemanggilan method, bukan membuat method tersebut menghilang dari assembly.

Jadi, secara sederhana:

DEBUG tersedia
    │
    └── pemanggilan LogDebugInfo() dipertahankan

DEBUG tidak tersedia
    │
    └── pemanggilan LogDebugInfo() dihilangkan

Attribute ini sering berguna untuk kebutuhan seperti logging atau debugging yang hanya diperlukan pada build tertentu.

Flags

[Flags]
public enum Permission
{
    None = 0,
    Read = 1,
    Write = 2,
    Execute = 4
}

FlagsAttribute digunakan untuk menunjukkan bahwa sebuah enum dirancang agar nilai-nilainya dapat dikombinasikan menggunakan operasi bitwise.

Contohnya:

var permission = Permission.Read | Permission.Write;

Sekarang permission merepresentasikan dua permission sekaligus:

Read
+
Write

Karena setiap nilai menggunakan bit yang berbeda:

Read    = 001
Write   = 010
Execute = 100

kombinasi:

Read | Write
001  | 010
-----------
011

dapat merepresentasikan dua nilai sekaligus.

[Flags] sendiri tidak mengubah cara operator | bekerja. Attribute tersebut terutama memberikan informasi mengenai maksud penggunaan enum dan juga memengaruhi representasi string enum tertentu, misalnya ketika dipanggil melalui ToString().

CLSCompliant

[CLSCompliant(true)]
public class PublicLibrary
{
}

CLSCompliantAttribute berkaitan dengan Common Language Specification (CLS).

.NET mendukung banyak bahasa pemrograman, seperti C#, Visual Basic, dan F#. Bahasa-bahasa tersebut dapat menghasilkan assembly yang menggunakan runtime dan type system .NET yang sama. Namun, setiap bahasa dapat memiliki fitur atau aturan yang berbeda. CLS menyediakan sekumpulan aturan umum agar public API sebuah library dapat digunakan dengan lebih mudah oleh berbagai bahasa .NET.

Misalnya, sebuah library dapat menandai API tertentu sebagai CLS-compliant:

[CLSCompliant(true)]
public class PublicLibrary
{
}

Compiler kemudian dapat membantu mendeteksi penggunaan fitur tertentu yang tidak sesuai dengan aturan CLS pada API tersebut. Dengan demikian, Attribute ini bukan berarti runtime melakukan pemeriksaan kompatibilitas setiap kali class digunakan. Fokus utamanya adalah memberikan informasi kepada compiler mengenai kepatuhan terhadap CLS.

ThreadStatic

public class Counter
{
    [ThreadStatic]
    public static int Value;
}

ThreadStaticAttribute digunakan pada static field untuk menunjukkan bahwa field tersebut memiliki nilai yang berbeda pada setiap thread. Tanpa [ThreadStatic], sebuah static field pada dasarnya memiliki satu storage yang dapat diakses oleh berbagai thread:

Thread 1 ──┐
Thread 2 ──┼──> static Value
Thread 3 ──┘

Dengan [ThreadStatic], setiap thread memiliki storage-nya sendiri:

Thread 1 ──> Value = 10

Thread 2 ──> Value = 20

Thread 3 ──> Value = 30

Contohnya:

public class Counter
{
    [ThreadStatic]
    public static int Value;
}

Jika thread pertama mengubah Value menjadi 10, perubahan tersebut tidak otomatis terlihat sebagai nilai 10 bagi thread kedua. Perlu diperhatikan bahwa ThreadStatic memiliki beberapa aturan penting, terutama mengenai inisialisasi field dan penggunaan static field. Karena itu, Attribute ini lebih cocok dipahami sebagai mekanisme runtime yang berkaitan dengan thread-local storage, bukan sekadar label biasa.

Attribute Tidak Selalu Diproses dengan Cara yang Sama

Keenam contoh tersebut menunjukkan satu hal penting: Attribute merupakan mekanisme metadata, tetapi pihak yang menggunakan metadata tersebut dapat berbeda-beda.

Misalnya:

[Obsolete]
    │
    └── digunakan oleh compiler

[Conditional]
    │
    └── digunakan oleh compiler

[Flags]
    │
    └── memberikan informasi mengenai penggunaan enum

[ThreadStatic]
    │
    └── digunakan oleh runtime

Sementara Attribute lain dapat dibaca dan digunakan oleh library atau framework tertentu. Karena itu, tidak tepat jika semua Attribute dianggap bekerja dengan mekanisme yang sama. Ada Attribute yang memengaruhi proses kompilasi, ada yang digunakan oleh runtime, dan ada pula yang menjadi metadata yang kemudian dibaca oleh library atau framework.

Namun, semuanya memiliki fondasi yang sama:

Attribute
    │
    ▼
Metadata
    │
    ▼
Compiler / Runtime / Library / Framework
    │
    ▼
Perilaku tertentu

Attribute sendiri tidak secara otomatis menjalankan logic aplikasi. Attribute menyediakan informasi. Komponen yang memahami Attribute tersebutlah yang menentukan bagaimana informasi tersebut digunakan.

Pemahaman ini akan menjadi semakin penting ketika mulai membuat Custom Attribute. Dengan Custom Attribute, mekanisme yang sama dapat digunakan untuk membuat metadata sendiri dan kemudian membangun kode yang membaca metadata tersebut menggunakan Reflection.

Bagian 7: Attribute pada Property

Salah satu tempat yang paling sering digunakan untuk Attribute adalah property pada sebuah class.

Contohnya:

public class UserDto
{
    [Key]
    public int Id { get; set; }

    [Required]
    public string Name { get; set; }

    [Column("email_address")]
    public string Email { get; set; }

    [JsonPropertyName("first_name")]
    public string FirstName { get; set; }
}

Masing-masing Attribute memberikan informasi yang berbeda mengenai property tempat Attribute tersebut ditempatkan.

• [Key] memberikan informasi bahwa property tersebut digunakan sebagai primary key.

• [Required] memberikan informasi bahwa property tersebut wajib memiliki nilai dalam konteks validasi yang mendukung Attribute tersebut.

• [Column("email_address")] memberikan informasi bahwa property Email dipetakan ke kolom database bernama email_address.

• [JsonPropertyName("first_name")] memberikan informasi bahwa FirstName menggunakan nama first_name ketika diproses oleh System.Text.Json.

Dari contoh tersebut terlihat bahwa satu class dapat memiliki Attribute dari berbagai library:

UserDto
│
├── [Key]
├── [Required]
├── [Column(...)]
└── [JsonPropertyName(...)]

Menariknya, masing-masing Attribute dapat digunakan oleh komponen yang berbeda.

Attribute dan Entity Framework

[Key] dan [Column] merupakan contoh Attribute yang umum digunakan dalam Entity Framework Core.

Misalnya:

public class User
{
    [Key]
    public int UserId { get; set; }

    [Column("email_address")]
    public string Email { get; set; }
}

Ketika Entity Framework Core membangun model dari class tersebut, informasi mengenai property perlu dikumpulkan.

Secara sederhana, prosesnya dapat dibayangkan seperti:

User class
    │
    ▼
Periksa property
    │
    ├── UserId
    │     └── [Key]
    │
    └── Email
          └── [Column("email_address")]
    │
    ▼
Model Entity Framework
    │
    ▼
Mapping ke database

Entity Framework dapat menggunakan Reflection dan mekanisme metadata .NET untuk mengetahui Attribute yang terdapat pada property. Jika menemukan [Key], informasi tersebut dapat digunakan dalam konfigurasi model untuk menentukan primary key.

Jika menemukan:

[Column("email_address")]
public string Email { get; set; }

Entity Framework dapat menggunakan email_address sebagai nama kolom ketika melakukan mapping ke database.

Dengan demikian, Attribute berfungsi sebagai sumber informasi, sedangkan Entity Framework adalah salah satu pihak yang membaca dan menggunakan informasi tersebut.

Attribute dan System.Text.Json

Pola yang sama juga dapat ditemukan pada System.Text.Json.

Contohnya:

public class User
{
    [JsonPropertyName("first_name")]
    public string FirstName { get; set; }
}

Ketika object tersebut diserialisasi, JsonSerializer dapat menggunakan informasi dari [JsonPropertyName] untuk menentukan nama property dalam JSON.

Misalnya:

var user = new User
{
    FirstName = "Budi"
};

Hasil serialisasinya dapat berupa:

{
    "first_name": "Budi"
}

Tanpa Attribute tersebut, nama yang digunakan dapat mengikuti konfigurasi naming policy yang sedang diterapkan oleh JsonSerializer.

Secara sederhana:

C# Property
    │
    ├── Name: FirstName
    │
    └── [JsonPropertyName("first_name")]
                 │
                 ▼
          JsonSerializer
                 │
                 ▼
       JSON property: first_name

Sekali lagi, [JsonPropertyName] tidak melakukan proses serialisasi dengan sendirinya. Attribute hanya menyediakan informasi. JsonSerializer membaca informasi tersebut dan menggunakannya ketika melakukan serialisasi atau deserialisasi.

Satu Mekanisme, Banyak Pengguna

Dari dua contoh tersebut terlihat pola yang cukup menarik. Entity Framework dan System.Text.Json merupakan library yang berbeda dan memiliki tujuan yang berbeda pula.

Namun, keduanya dapat menggunakan mekanisme metadata yang sama:

                C# Code
                   │
                   ▼
             Attribute
                   │
                   ▼
              Metadata
              /       \
             /         \
            ▼           ▼
   Entity Framework   JsonSerializer
            │           │
            ▼           ▼
     Database Mapping   JSON Mapping

Entity Framework tidak perlu mengetahui bagaimana JsonPropertyName bekerja. Sebaliknya, System.Text.Json juga tidak perlu mengetahui bagaimana [Key] digunakan oleh Entity Framework. Masing-masing library cukup membaca Attribute yang memang menjadi tanggung jawabnya. Hal ini membuat mekanisme Attribute cukup fleksibel. Sebuah class dapat memiliki metadata dari berbagai library sekaligus, dan masing-masing library dapat mengambil informasi yang relevan bagi kebutuhannya.

Pola yang Sama di Banyak Tempat

Pada tahap ini, pola penggunaan Attribute mulai terlihat:

Attribute ditempatkan pada kode
           │
           ▼
Informasi menjadi bagian dari metadata
           │
           ▼
Library / framework membaca metadata
           │
           ▼
Informasi digunakan untuk menentukan perilaku

Pada property, informasi tersebut dapat digunakan untuk mapping database atau JSON. Pada method, Attribute dapat digunakan untuk memberikan informasi mengenai routing, authorization, testing, dan berbagai kebutuhan lainnya. Pada class, Attribute dapat memberikan informasi mengenai konfigurasi atau karakteristik tertentu dari type tersebut. Bahkan, Attribute juga dapat ditempatkan pada assembly untuk memberikan informasi pada tingkat yang lebih luas.

Jadi, property hanyalah salah satu tempat Attribute dapat digunakan. Mekanisme dasarnya tetap sama: Attribute menyediakan metadata, kemudian komponen lain yang memahami metadata tersebut memanfaatkannya.

Bagian 8: Attribute pada Method

Selain property, method juga merupakan salah satu tempat yang sangat umum untuk menggunakan Attribute. Beberapa contohnya dapat ditemukan dalam ASP.NET Core maupun framework testing seperti xUnit:

[HttpGet]
public IActionResult GetAllUsers()
{
    // ...
}

[Fact]
public void Addition_ShouldReturnCorrectSum()
{
    // ...
}

[Theory]
[InlineData(1, 2, 3)]
public void Addition_WithMultipleInputs(
    int a,
    int b,
    int expected)
{
    // ...
}

Masing-masing Attribute memberikan informasi yang berbeda. Pada ASP.NET Core, [HttpGet] memberikan informasi bahwa method tersebut dapat digunakan untuk menangani HTTP GET. Pada xUnit, [Fact] menandai method sebagai test case yang dapat dijalankan oleh test runner. Sementara itu, [Theory] menandai test yang dapat dijalankan menggunakan beberapa kombinasi data. [InlineData] kemudian menyediakan data yang digunakan oleh test tersebut.

Bagaimana Framework Menemukan Method Tersebut?

Pertanyaan yang menarik adalah: bagaimana framework mengetahui method mana yang harus diperlakukan secara khusus? Sebuah assembly dapat memiliki banyak class dan setiap class dapat memiliki banyak method.

Misalnya:

Assembly
│
├── UserService
│   ├── GetUsers()
│   ├── CreateUser()
│   └── DeleteUser()
│
├── OrderService
│   ├── GetOrders()
│   └── CreateOrder()
│
└── UserTests
    ├── TestUserCreation()
    ├── TestUserDeletion()
    └── TestUserValidation()

Tidak semua method tersebut memiliki tujuan yang sama. Test runner hanya perlu menemukan method yang merupakan test. ASP.NET Core hanya perlu menemukan method yang dapat menjadi endpoint. Di sinilah metadata dari Attribute menjadi berguna.

Secara umum, framework dapat menggunakan Reflection untuk memeriksa type dan method yang tersedia, kemudian melihat Attribute yang melekat pada masing-masing method.

Contoh pada Test Runner

Sebagai gambaran sederhana, proses yang dilakukan test runner dapat dibayangkan seperti berikut:

Assembly Test
      │
      ▼
Cari class
      │
      ▼
Cari method
      │
      ▼
Periksa Attribute
      │
      ├── [Fact] ──────► Test Case
      │
      ├── [Theory] ────► Test Case + Data
      │
      └── Tidak ada ───► Abaikan

Secara konseptual, langkahnya kurang lebih seperti ini:

1. Test runner menemukan assembly yang berisi test.

2. Assembly tersebut diperiksa untuk menemukan type yang relevan.

3. Method pada type tersebut diperiksa.

4. Attribute pada setiap method diperiksa.

5. Method dengan [Fact] atau [Theory] dikenali sebagai test.

6. Test runner kemudian membangun informasi yang diperlukan untuk menjalankan test tersebut.

7. Hasil setiap test dilaporkan.

Implementasi sebenarnya tentu lebih kompleks. Test runner perlu menangani berbagai hal lain seperti lifecycle, dependency, data test, exception, parallel execution, dan sebagainya. Namun, pola dasarnya tetap dapat dipahami melalui metadata Attribute.

Contoh pada ASP.NET Core

ASP.NET Core menggunakan pola yang serupa, tetapi tujuannya berbeda.

Misalnya terdapat controller:

public class UsersController : ControllerBase
{
    [HttpGet]
    public IActionResult GetAllUsers()
    {
        // ...
    }

    [HttpPost]
    public IActionResult CreateUser()
    {
        // ...
    }
}

Dari dua method tersebut, ASP.NET Core perlu mengetahui bahwa:

GetAllUsers()
    └── [HttpGet]

CreateUser()
    └── [HttpPost]

memiliki aturan HTTP yang berbeda.

Informasi tersebut kemudian digunakan bersama informasi routing lainnya untuk membangun endpoint aplikasi.

Secara sederhana:

Controller
    │
    ▼
Method
    │
    ├── [HttpGet]
    │
    └── [HttpPost]
    │
    ▼
Endpoint metadata
    │
    ▼
Routing system
    │
    ▼
HTTP Request

Ketika sebuah request HTTP masuk, routing system dapat menentukan endpoint yang sesuai berdasarkan informasi seperti URL, HTTP method, dan metadata endpoint yang telah dibangun sebelumnya.

Perlu dicatat bahwa ASP.NET Core tidak harus melakukan Reflection dari awal setiap kali request masuk. Framework dapat melakukan proses discovery dan membangun representasi endpoint ketika aplikasi sedang menyiapkan routing. Jadi, Reflection merupakan salah satu mekanisme yang dapat digunakan dalam proses menemukan metadata, bukan berarti seluruh assembly dipindai ulang untuk setiap request.

Attribute sebagai Penanda

Dari contoh xUnit dan ASP.NET Core, terlihat satu pola yang sama:

Method
  │
  └── Attribute
         │
         ▼
   Informasi tambahan
         │
         ▼
Framework membaca informasi
         │
         ▼
Menentukan perlakuan terhadap method

Method tidak perlu ditulis dengan bentuk khusus agar framework dapat mengenalinya.

Misalnya, method berikut tetap merupakan method C# biasa:

[HttpGet]
public IActionResult GetAllUsers()
{
    return Ok();
}

Yang memberikan informasi tambahan adalah [HttpGet].

Framework kemudian memiliki mekanisme sendiri untuk mencari dan membaca informasi tersebut.

Attribute Tidak Menentukan Logic Method

Hal penting lainnya adalah Attribute tidak mengubah logic method secara langsung.

Misalnya:

[HttpGet]
public IActionResult GetAllUsers()
{
    return Ok(users);
}

[HttpGet] tidak membuat GetAllUsers() menjalankan proses HTTP GET di dalam method tersebut.

Method tetap hanya berisi logic:

return Ok(users);

Sementara [HttpGet] memberikan informasi mengenai kapan dan melalui mekanisme apa method tersebut dapat dipanggil oleh framework.

Dengan demikian, dapat dibedakan:

Method
└── Menentukan apa yang dilakukan

Attribute
└── Memberikan informasi tentang method

Framework
└── Membaca informasi dan menentukan bagaimana method digunakan

Pola inilah yang membuat Attribute sangat berguna dalam framework. Satu method dapat tetap ditulis sebagai method biasa, tetapi dengan menambahkan metadata, framework dapat memperlakukannya sebagai endpoint HTTP, test case, handler, atau elemen khusus lainnya.

Pada titik ini, pola yang sebelumnya terlihat pada property mulai terlihat kembali pada method. Attribute tetap berfungsi sebagai metadata; yang berubah hanyalah elemen kode yang diberi metadata.

Bagian 9: Attribute pada Class

Selain property dan method, Attribute juga dapat ditempatkan langsung pada class. Contohnya cukup mudah ditemukan dalam aplikasi ASP.NET Core:

[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    [Authorize]
    public IActionResult GetProfile()
    {
        // ...
    }
}

Contoh lainnya:

[Serializable]
public class UserSession
{
    public string Token { get; set; }
}

Pada contoh pertama, [ApiController] dan [Route] ditempatkan pada class UsersController, sedangkan [Authorize] ditempatkan pada method. Masing-masing Attribute memberikan informasi yang berbeda kepada ASP.NET Core.

Attribute pada Class dan Cakupannya

Perbedaan penting antara Attribute pada class dengan Attribute pada method atau property adalah cakupan konteksnya.

Misalnya:

public class User
{
    [Required]
    public string Name { get; set; }
}

[Required] berada pada property Name, sehingga informasi tersebut berkaitan dengan property tersebut.

Sementara:

[SomeAttribute]
public class User
{
}

Attribute berada pada level class. Framework yang membaca Attribute tersebut dapat menggunakan informasinya untuk menentukan bagaimana User harus diperlakukan. Namun, perlu diperhatikan bahwa Attribute pada class tidak otomatis berlaku pada semua isi class. Cakupannya ditentukan oleh kode yang membaca Attribute tersebut.

Misalnya, sebuah framework dapat memilih untuk menggunakan Attribute pada class sebagai konfigurasi untuk seluruh method di dalamnya. Framework lain mungkin hanya menggunakan Attribute tersebut untuk menentukan karakteristik class itu sendiri.

Jadi, lebih tepat jika dipahami seperti ini:

Attribute pada Property
        │
        └── informasi tentang property

Attribute pada Method
        │
        └── informasi tentang method

Attribute pada Class
        │
        └── informasi tentang class
             │
             └── framework dapat memilih
                 bagaimana informasi tersebut
                 diterapkan

Contoh [ApiController]

Dalam ASP.NET Core, salah satu contoh yang mudah ditemui adalah [ApiController]:

[ApiController]
public class UsersController : ControllerBase
{
}

Attribute tersebut memberikan informasi kepada ASP.NET Core bahwa controller tersebut merupakan API controller. Informasi tersebut kemudian digunakan oleh framework untuk mengaktifkan sejumlah perilaku yang berkaitan dengan API controller, seperti automatic model validation dan inference tertentu dalam binding parameter.

Dengan demikian, Attribute tersebut tidak berisi logic untuk melakukan validasi atau membaca request body. [ApiController] hanya memberikan metadata. ASP.NET Core kemudian membaca metadata tersebut dan menerapkan perilaku yang sesuai.

Contoh [Route]

Attribute lain yang sering ditempatkan pada class adalah [Route]:

[Route("api/[controller]")]
public class UsersController : ControllerBase
{
}

Dalam konteks routing ASP.NET Core, route pada class dapat menjadi bagian dari template URL yang digunakan oleh endpoint di dalam controller.

Misalnya:

[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    [HttpGet]
    public IActionResult GetUsers()
    {
        // ...
    }
}

Secara sederhana dapat dibayangkan:

Controller
    │
    └── [Route("api/[controller]")]
              │
              ▼
        Route dasar
              │
              +
              │
        [HttpGet]
              │
              ▼
          Endpoint

Dengan cara ini, Attribute pada class dapat memberikan informasi yang kemudian digunakan bersama Attribute pada method.

[Authorize] pada Class

[Authorize] juga dapat ditempatkan pada level class:

[Authorize]
public class UsersController : ControllerBase
{
    [HttpGet]
    public IActionResult GetProfile()
    {
        // ...
    }

    [HttpGet("settings")]
    public IActionResult GetSettings()
    {
        // ...
    }
}

Dalam konteks ASP.NET Core, penggunaan [Authorize] pada controller berarti authorization requirement tersebut berlaku terhadap action di dalam controller tersebut. Dengan demikian, beberapa endpoint dapat memiliki aturan yang sama tanpa perlu menuliskan Attribute yang sama pada setiap method. Jika terdapat action tertentu yang memang harus dapat diakses tanpa authentication, [AllowAnonymous] dapat digunakan pada action tersebut.

Contohnya:

[Authorize]
public class UsersController : ControllerBase
{
    [HttpGet]
    public IActionResult GetProfile()
    {
        // Membutuhkan authorization
    }

    [AllowAnonymous]
    [HttpGet("public")]
    public IActionResult GetPublicProfile()
    {
        // Tidak memerlukan authorization
    }
}

Di sini terlihat bahwa Attribute pada class dapat memberikan aturan yang berlaku lebih luas, sementara Attribute pada method dapat memberikan konfigurasi yang lebih spesifik.

Class sebagai Konteks yang Lebih Luas

Contoh tersebut menunjukkan pola yang cukup umum:

Class
│
├── Method A
├── Method B
└── Method C

Attribute pada class memberikan informasi pada konteks yang lebih luas:

[Authorize]
Class
│
├── Method A  ← berlaku
├── Method B  ← berlaku
└── Method C  ← berlaku

Kemudian method tertentu dapat memiliki metadata tambahan:

[Authorize]
Class
│
├── Method A  ← authorize
├── Method B  ← authorize
└── [AllowAnonymous]
    Method C  ← pengecualian

Namun, sekali lagi, perilaku tersebut bukan merupakan aturan universal dari C#. C# hanya menyediakan kemampuan untuk menempelkan Attribute pada elemen tertentu. Bagaimana Attribute tersebut memengaruhi elemen lain ditentukan oleh framework atau kode yang membacanya.

Attribute Memiliki Target yang Berbeda

Attribute dalam C# dapat ditempatkan pada berbagai elemen program, tergantung pada Attribute tersebut mengizinkan target apa saja.

Beberapa target yang umum antara lain:

Assembly
   │
   └── informasi tingkat assembly

Class
   │
   └── informasi tentang type

Method
   │
   └── informasi tentang method

Property
   │
   └── informasi tentang property

Parameter
   │
   └── informasi tentang parameter

Bahkan terdapat target lain seperti field, event, constructor, return value, dan generic parameter. Jadi, posisi Attribute bukan sekadar masalah penempatan syntax. Posisi tersebut menentukan elemen mana yang memiliki metadata tersebut. Hal ini juga berkaitan dengan AttributeUsage, yang dapat digunakan untuk menentukan pada target mana sebuah Custom Attribute boleh digunakan.

Pembahasan mengenai AttributeUsage akan menjadi lebih menarik ketika mulai membuat Custom Attribute sendiri. Sebelum sampai ke sana, masih ada satu tingkat yang perlu diperhatikan: assembly. Jika class, method, dan property mewakili bagian-bagian di dalam sebuah program, assembly dapat dipandang sebagai konteks yang mencakup keseluruhan hasil kompilasi.

Bagian 10: Attribute pada Assembly

Setelah membahas Attribute pada property, method, dan class, masih ada satu level yang memiliki cakupan lebih luas, yaitu assembly. Jika Attribute pada property memberikan informasi tentang satu property, Attribute pada method memberikan informasi tentang satu method, dan Attribute pada class memberikan informasi tentang satu class, maka Assembly Attribute memberikan informasi tentang keseluruhan assembly.

Dalam konteks .NET, assembly merupakan hasil kompilasi aplikasi atau library yang umumnya berbentuk file .dll atau .exe.

Menulis Assembly Attribute

Contoh sederhana Assembly Attribute:

[assembly: CLSCompliant(true)]

Ada bagian yang terlihat berbeda dari Attribute yang sebelumnya dibahas:

[assembly: ...]
   │
   └── assembly

assembly: disebut attribute target specifier.

Specifier ini digunakan untuk memberi tahu compiler bahwa Attribute tersebut ditujukan pada assembly, bukan pada class, method, property, atau elemen kode lain di sekitarnya.

Tanpa target tersebut, compiler akan menentukan target berdasarkan konteks tempat Attribute ditulis.

Dengan menuliskan:

[assembly: CLSCompliant(true)]

targetnya dinyatakan secara eksplisit:

CLSCompliant
      │
      ▼
  Assembly
      │
      ├── Class A
      ├── Class B
      ├── Class C
      └── ...

Di Mana Assembly Attribute Diletakkan?

Secara historis, Assembly Attribute sering ditempatkan dalam file bernama:

Properties/AssemblyInfo.cs

Misalnya:

using System.Reflection;

[assembly: AssemblyTitle("MyApplication")]
[assembly: AssemblyDescription("Aplikasi contoh")]
[assembly: AssemblyVersion("1.0.0.0")]

Namun, Attribute tersebut sebenarnya tidak harus berada di AssemblyInfo.cs. Selama syntax-nya valid dan berada dalam project yang sama, Assembly Attribute dapat ditulis di file .cs lainnya. Pada project .NET modern, banyak informasi assembly bahkan dapat dikonfigurasi langsung melalui file project .csproj.

Contohnya:

<PropertyGroup>
    <AssemblyTitle>MyApplication</AssemblyTitle>
    <AssemblyDescription>Aplikasi contoh</AssemblyDescription>
    <AssemblyVersion>1.0.0.0</AssemblyVersion>
</PropertyGroup>

MSBuild kemudian dapat menghasilkan Assembly Attribute yang sesuai ketika project dikompilasi. Karena itu, AssemblyInfo.cs lebih tepat dipahami sebagai salah satu tempat untuk menuliskan Assembly Attribute, bukan tempat yang wajib digunakan.

Metadata tentang Assembly

Assembly Attribute biasanya digunakan untuk menyimpan informasi yang memang berkaitan dengan assembly secara keseluruhan.

Misalnya:

[assembly: AssemblyTitle("MyApplication")]
[assembly: AssemblyDescription("Aplikasi contoh")]
[assembly: AssemblyVersion("1.0.0.0")]

Informasi tersebut memberikan metadata seperti:

Assembly
├── Title       → MyApplication
├── Description → Aplikasi contoh
└── Version     → 1.0.0.0

Metadata tersebut dapat dibaca oleh berbagai tools atau aplikasi. Misalnya, informasi versi assembly dapat digunakan oleh sistem untuk mengetahui versi library yang sedang digunakan.

Metadata assembly juga dapat dibaca secara programatis menggunakan Reflection:

var assembly = typeof(MyApplication).Assembly;

var name = assembly.GetName();

Console.WriteLine(name.Name);
Console.WriteLine(name.Version);

Selain informasi yang berkaitan dengan identitas assembly, Attribute pada level assembly juga dapat digunakan untuk kebutuhan tertentu yang memang cakupannya berada pada level assembly.

Memilih Level Attribute yang Tepat

Sampai titik ini, beberapa level penempatan Attribute sudah terlihat:

Assembly
   │
   └── Class
        │
        ├── Property
        │
        └── Method

Pemilihan level sebaiknya mengikuti cakupan informasi yang ingin diberikan.

Jika informasi hanya berkaitan dengan satu property:

[Required]
public string Name { get; set; }

Attribute ditempatkan pada property.

Jika informasi hanya berkaitan dengan satu method:

[HttpGet]
public IActionResult GetUsers()
{
    // ...
}

Attribute ditempatkan pada method.

Jika informasi berkaitan dengan sebuah class:

[ApiController]
public class UsersController : ControllerBase
{
}

Attribute ditempatkan pada class.

Sedangkan jika informasi berkaitan dengan keseluruhan assembly:

[assembly: CLSCompliant(true)]

Attribute ditempatkan pada assembly.

Dengan cara ini, metadata berada sedekat mungkin dengan scope yang memang membutuhkannya.

Attribute Target Tidak Sama dengan Pengaruhnya

Ada satu hal penting yang perlu dibedakan. Target Attribute menentukan elemen tempat metadata tersebut ditempelkan. Namun, seberapa luas metadata tersebut memengaruhi perilaku aplikasi bergantung pada kode yang membacanya.

Misalnya, [Authorize] pada class dapat digunakan ASP.NET Core sebagai aturan yang berlaku pada action di dalam controller. Ini bukan karena C# secara otomatis menyebarkan Attribute dari class ke semua method. Framework-lah yang menentukan bagaimana Attribute tersebut ditafsirkan. Hal yang sama berlaku pada Assembly Attribute. Menempatkan Attribute pada assembly tidak berarti semua class di dalam assembly otomatis memiliki Attribute tersebut.

Secara sederhana:

Attribute Target
      │
      ▼
Menentukan tempat metadata ditempelkan

Attribute Consumer
      │
      ▼
Menentukan bagaimana metadata digunakan

C# menyediakan mekanisme untuk menyimpan metadata. Compiler, runtime, atau framework kemudian dapat membaca metadata tersebut dan menentukan perilakunya masing-masing.

Dengan demikian, seluruh level utama yang telah dibahas dapat dirangkum sebagai berikut:

Assembly
   │
   ├── Class
   │    │
   │    ├── Property
   │    │
   │    └── Method
   │
   └── ...

Attribute dapat digunakan pada berbagai bagian tersebut selama Attribute yang digunakan memang mengizinkan target tersebut.

Setelah memahami di mana Attribute dapat ditempatkan, pembahasan berikutnya akan beralih pada pertanyaan lain yang tidak kalah penting: bagaimana Attribute dapat membawa data?

Contohnya:

[Obsolete("Gunakan CalculateV2()")]

Teks "Gunakan CalculateV2()" bukan sekadar bagian dari syntax. Nilai tersebut dikirim sebagai argument dan akan menjadi bagian dari informasi yang dibawa oleh Attribute.

Untuk memahami mekanismenya, pembahasan berikutnya akan melihat constructor pada Attribute dan bagaimana parameter dapat diberikan ketika Attribute digunakan.

Bagian 11: Constructor pada Attribute

Pada bagian sebelumnya sudah dibahas bahwa Attribute pada dasarnya adalah sebuah class. Karena itu, Attribute juga dapat memiliki constructor, sama seperti class pada umumnya. Constructor inilah yang memungkinkan sebuah Attribute menerima data ketika digunakan.

Contoh yang cukup familiar adalah:

[Obsolete("Gunakan CalculateV2()")]
public int Calculate(int a, int b)
{
    return a + b;
}

Teks:

"Gunakan CalculateV2()"

yang berada di dalam tanda kurung bukan sekadar teks bebas. Nilai tersebut merupakan argument yang diberikan kepada constructor ObsoleteAttribute.

Constructor pada Attribute

Secara sederhana, ObsoleteAttribute dapat dibayangkan memiliki definisi seperti berikut:

public class ObsoleteAttribute : Attribute
{
    public string Message { get; }

    public ObsoleteAttribute(string message)
    {
        Message = message;
    }
}

Dengan constructor tersebut, Attribute dapat menerima sebuah string ketika digunakan:

[Obsolete("Gunakan CalculateV2()")]

Secara konsep, hubungan keduanya dapat dibayangkan seperti:

[Obsolete("Gunakan CalculateV2()")]
                │
                ▼
ObsoleteAttribute(string message)
                │
                ▼
message = "Gunakan CalculateV2()"

Jadi, Attribute dapat membawa informasi tambahan melalui parameter constructor.

Apakah Ini Sama dengan new?

Dari sudut pandang konsep, syntax:

[Obsolete("Gunakan CalculateV2()")]

dapat dibandingkan dengan:

new ObsoleteAttribute("Gunakan CalculateV2()");

Keduanya sama-sama berkaitan dengan constructor ObsoleteAttribute.

Namun, keduanya bukan operasi yang sama dalam source code.

Ketika menggunakan:

new ObsoleteAttribute("Gunakan CalculateV2()");

object dibuat secara eksplisit sebagai bagian dari logic program.

Sedangkan ketika menggunakan:

[Obsolete("Gunakan CalculateV2()")]

compiler memperlakukan syntax tersebut sebagai deklarasi Attribute dan menyimpan informasi yang diperlukan ke dalam metadata assembly.

Ketika metadata tersebut kemudian dibaca, misalnya melalui Reflection, .NET dapat membuat instance Attribute berdasarkan informasi yang tersimpan.

Secara sederhana:

[Obsolete("...")]
        │
        │ compile
        ▼
Metadata dalam Assembly
        │
        │ Reflection
        ▼
ObsoleteAttribute instance

Perbedaan ini penting karena membantu membedakan antara deklarasi metadata dan pembuatan object secara langsung dalam logic program.

Attribute Dapat Memiliki Beberapa Constructor

Karena Attribute adalah class, Attribute juga dapat memiliki lebih dari satu constructor. Ini sama seperti class biasa yang mendukung constructor overloading.

ObsoleteAttribute, misalnya, menyediakan beberapa bentuk penggunaan:

[Obsolete]

[Obsolete("Gunakan CalculateV2()")]

[Obsolete("Gunakan CalculateV2()", true)]

Ketiganya menggunakan constructor yang berbeda.

Secara konseptual:

[Obsolete]
    │
    └── ObsoleteAttribute()

[Obsolete("Gunakan CalculateV2()")]
    │
    └── ObsoleteAttribute(string)

[Obsolete("Gunakan CalculateV2()", true)]
    │
    └── ObsoleteAttribute(string, bool)

Pada bentuk pertama, tidak ada argument yang diberikan. Pada bentuk kedua, terdapat satu argument berupa string yang digunakan sebagai pesan. Pada bentuk ketiga, terdapat dua argument:

"Gunakan CalculateV2()"
true

Argument bool tersebut menentukan apakah penggunaan elemen yang ditandai sebagai obsolete harus dianggap sebagai error oleh compiler.

Positional Parameter

Argument yang diberikan melalui constructor Attribute disebut positional parameter karena nilainya ditentukan berdasarkan posisi.

Misalnya:

[Obsolete("Gunakan CalculateV2()", true)]

dapat dipahami sebagai:

Parameter pertama → "Gunakan CalculateV2()"
Parameter kedua   → true

Urutannya penting.

Jika constructor didefinisikan seperti:

public MyAttribute(string message, bool isError)
{
}

maka:

[My("Pesan", true)]

berarti:

message  = "Pesan"
isError  = true

Sedangkan membalik urutannya:

[My(true, "Pesan")]

tidak valid jika tidak terdapat constructor yang menerima parameter dengan urutan tersebut.

Constructor Bukan Satu-satunya Cara Memberikan Data

Constructor memang dapat digunakan untuk memberikan data kepada Attribute, tetapi bukan satu-satunya cara. Attribute juga dapat memiliki property atau field yang nilainya dapat ditentukan ketika Attribute digunakan.

Misalnya:

public class AuthorAttribute : Attribute
{
    public string Name { get; }

    public string Role { get; set; }

    public AuthorAttribute(string name)
    {
        Name = name;
    }
}

Attribute tersebut dapat digunakan seperti:

[Author("Budi", Role = "Developer")]
public class UserService
{
}

Di sini terdapat dua cara memberikan nilai:

"Budi"
    │
    └── constructor parameter

Role = "Developer"
    │
    └── named parameter

Jadi, terdapat dua konsep yang perlu dibedakan:

Positional parameter

Nilai diberikan melalui constructor:

[Author("Budi")]

Named parameter

Nilai diberikan melalui property atau field:

[Author("Budi", Role = "Developer")]

Keduanya dapat digunakan bersama.

Pembahasan mengenai named parameter akan dilanjutkan pada bagian berikutnya, termasuk aturan mengenai property dan field seperti apa yang dapat digunakan sebagai named parameter pada Attribute.

Bagian 12: Named Parameter

Pada bagian sebelumnya sudah dibahas positional parameter, yaitu nilai yang diberikan kepada Attribute melalui constructor dan ditentukan berdasarkan urutan parameternya. Selain positional parameter, Attribute juga memiliki mekanisme lain untuk menerima nilai, yaitu named parameter. Named parameter memungkinkan property atau field tertentu pada Attribute diisi secara langsung ketika Attribute digunakan.

Contoh Named Parameter

Perhatikan contoh berikut:

[Obsolete(
    "Deprecated",
    IsError = true)]
public void OldMethod()
{
}

Pada contoh tersebut terdapat dua bentuk pemberian nilai:

"Deprecated"
    │
    └── positional parameter

IsError = true
    │
    └── named parameter

"Deprecated" dikirim ke constructor ObsoleteAttribute.

Sementara IsError = true digunakan untuk mengatur property IsError pada Attribute. Dengan kata lain, named parameter tidak membutuhkan constructor khusus yang menerima IsError sebagai parameter.

Contoh Custom Attribute

Agar perbedaannya lebih jelas, perhatikan Custom Attribute berikut:

public class InfoAttribute : Attribute
{
    public string Description { get; }

    public string Author { get; set; }

    public InfoAttribute(string description)
    {
        Description = description;
    }
}

Class tersebut memiliki dua bagian penting:

Description
    │
    └── diisi melalui constructor

Author
    │
    └── diisi melalui named parameter

Constructor hanya menerima description:

public InfoAttribute(string description)
{
    Description = description;
}

Sementara Author merupakan public property yang dapat diisi setelah Attribute dibuat:

public string Author { get; set; }

Attribute tersebut kemudian dapat digunakan seperti ini:

[Info(
    "Method ini menghitung total harga",
    Author = "Tim Backend")]
public decimal CalculateTotal()
{
    // ...
}

Nilai "Method ini menghitung total harga" merupakan positional parameter.

Sementara:

Author = "Tim Backend"

merupakan named parameter.

Bagaimana Membayangkannya?

Secara konsep, penggunaan tersebut dapat dibayangkan mirip dengan object initializer:

new InfoAttribute("Method ini menghitung total harga")
{
    Author = "Tim Backend"
};

Namun, perlu diingat bahwa syntax Attribute bukan sekadar object initializer yang ditulis langsung di source code. Compiler memproses syntax Attribute sebagai metadata dan menyimpan informasi yang diperlukan dalam metadata assembly.

Object initializer di atas hanya digunakan sebagai analogi untuk memahami dari mana nilai Author berasal.

Secara sederhana:

[Info("Method ini menghitung total harga",
      Author = "Tim Backend")]
                 │
                 ├── constructor
                 │
                 └── property

Positional dan Named Parameter

Perbedaan keduanya dapat dirangkum sebagai berikut:

Misalnya:

[Info("Method untuk menghitung harga")]

hanya memberikan positional parameter.

Sedangkan:

[Info(
    "Method untuk menghitung harga",
    Author = "Tim Backend")]

menggunakan keduanya.

Named Parameter Harus Menggunakan Property atau Field yang Valid

Tidak semua member dapat digunakan sebagai named parameter. Member tersebut harus berupa public property atau public field yang dapat diisi.

Contohnya:

public class InfoAttribute : Attribute
{
    public string Description { get; }

    public string Author { get; set; }

    public string Category;
    
    public InfoAttribute(string description)
    {
        Description = description;
    }
}

Author dapat digunakan sebagai named parameter karena merupakan public property yang memiliki setter:

[Info("Perhitungan harga", Author = "Backend")]

Category juga dapat digunakan karena merupakan public field:

[Info("Perhitungan harga", Category = "Finance")]

Sebaliknya, property yang hanya memiliki getter tidak dapat digunakan untuk menerima nilai:

public string Description { get; }

Property tersebut bersifat read-only dari luar class. Nilainya harus diberikan melalui constructor.

Karena itu, desain seperti berikut cukup umum:

public class InfoAttribute : Attribute
{
    // Wajib
    public string Description { get; }

    // Opsional
    public string Author { get; set; }

    public InfoAttribute(string description)
    {
        Description = description;
    }
}

Penggunaannya:

[Info("Method untuk menghitung harga")]

atau:

[Info(
    "Method untuk menghitung harga",
    Author = "Tim Backend")]

Dengan desain seperti ini, Description menjadi informasi yang harus tersedia ketika Attribute dibuat, sedangkan Author menjadi informasi tambahan yang hanya perlu diberikan jika memang diperlukan.

Kapan Menggunakan Positional dan Named Parameter?

Kombinasi keduanya dapat membantu menentukan mana informasi yang bersifat wajib dan mana yang bersifat opsional.

Misalnya sebuah Attribute membutuhkan nama sebagai informasi utama:

public class AuthorAttribute : Attribute
{
    public string Name { get; }

    public string Role { get; set; }

    public string Team { get; set; }

    public AuthorAttribute(string name)
    {
        Name = name;
    }
}

Penggunaannya dapat dibuat seperti:

[Author("Budi")]

atau:

[Author(
    "Budi",
    Role = "Software Engineer",
    Team = "Backend")]

Dalam desain tersebut:

Name
  │
  └── informasi utama
      → constructor

Role
  │
  └── informasi tambahan
      → named parameter

Team
  │
  └── informasi tambahan
      → named parameter

Pendekatan ini membuat Custom Attribute dapat memiliki API yang cukup jelas: informasi penting diberikan melalui constructor, sedangkan informasi tambahan diberikan hanya ketika diperlukan. Dengan memahami positional dan named parameter, sudah ada cukup bekal untuk mulai membuat Custom Attribute sendiri.

Bagian 13: Membuat Custom Attribute

Sampai tahap ini, beberapa konsep penting sudah dibahas:

• Attribute pada dasarnya adalah class.

• Custom Attribute mewarisi System.Attribute.

• Attribute dapat memiliki constructor.

• Constructor dapat menerima positional parameter.

• Property atau field tertentu dapat digunakan sebagai named parameter.

Konsep-konsep tersebut menjadi dasar untuk membuat Custom Attribute sendiri. Sebagai contoh, akan dibuat AuthorAttribute, yaitu Attribute sederhana yang digunakan untuk mencatat siapa yang menulis sebuah class, method, atau elemen kode lainnya. Informasi seperti ini dapat dimanfaatkan untuk berbagai kebutuhan, misalnya dokumentasi, audit, atau tooling internal.

Langkah 1 — Membuat Class yang Mewarisi Attribute

Langkah pertama adalah membuat class yang mewarisi System.Attribute:

public class AuthorAttribute : Attribute
{
}

Inilah bagian yang membedakan Custom Attribute dari class biasa. Dengan mewarisi Attribute, AuthorAttribute dikenali sebagai class yang dapat digunakan sebagai Attribute:

[Author]
public class ReportGenerator
{
}

Tanpa pewarisan tersebut, AuthorAttribute hanyalah class biasa dan tidak dapat digunakan dengan syntax Attribute seperti di atas.

Langkah 2 — Menambahkan Property untuk Menyimpan Data

Tujuan AuthorAttribute adalah menyimpan nama penulis.

Karena itu, diperlukan property untuk menyimpan informasi tersebut:

public class AuthorAttribute : Attribute
{
    public string Name { get; }
}

Property Name dibuat read-only:

public string Name { get; }

Artinya, nilai Name dapat dibaca dari luar class, tetapi tidak dapat diubah melalui assignment biasa setelah object terbentuk.

Desain seperti ini cocok untuk informasi yang dianggap sebagai bagian utama dari identitas Attribute.

Langkah 3 — Menambahkan Constructor

Property Name sekarang sudah tersedia, tetapi belum ada cara untuk mengisinya.

Constructor dapat digunakan untuk tujuan tersebut:

public class AuthorAttribute : Attribute
{
    public string Name { get; }

    public AuthorAttribute(string name)
    {
        Name = name;
    }
}

Dengan constructor tersebut, AuthorAttribute membutuhkan sebuah string ketika dibuat.

Hal ini memungkinkan penggunaan seperti:

[Author("John")]
public class ReportGenerator
{
}

Nilai:

"John"

diberikan kepada parameter name pada constructor.

Secara sederhana:

[Author("John")]
       │
       ▼
AuthorAttribute(string name)
       │
       ▼
Name = "John"

Dengan demikian, Name menjadi positional parameter dari Attribute tersebut.

Langkah 4 — Menggunakan Custom Attribute

Setelah class selesai dibuat, Attribute dapat digunakan pada elemen kode:

[Author("John")]
public class ReportGenerator
{
    [Author("Jane")]
    public void GenerateReport()
    {
        Console.WriteLine("Laporan berhasil dibuat.");
    }
}

Pada contoh tersebut, AuthorAttribute digunakan pada dua level:

ReportGenerator
│
├── [Author("John")]
│
└── GenerateReport()
       │
       └── [Author("Jane")]

Ini menunjukkan bahwa sebuah Custom Attribute dapat digunakan pada beberapa jenis elemen kode, selama target tersebut diizinkan oleh Attribute. Sampai tahap ini, belum ada pembatasan yang secara eksplisit menentukan apakah AuthorAttribute hanya boleh digunakan pada class, method, property, atau elemen lainnya. Pembatasan tersebut dapat dibuat menggunakan AttributeUsage, yang akan dibahas pada bagian berikutnya.

Langkah 5 — Menambahkan Named Parameter

AuthorAttribute saat ini hanya menyimpan nama penulis.

Agar lebih berguna, dapat ditambahkan informasi tambahan, misalnya tanggal review:

public class AuthorAttribute : Attribute
{
    public string Name { get; }

    public string ReviewDate { get; set; }

    public AuthorAttribute(string name)
    {
        Name = name;
    }
}

Name tetap menjadi property read-only yang diisi melalui constructor.

Sementara ReviewDate memiliki setter sehingga dapat digunakan sebagai named parameter.

Contoh penggunaannya:

[Author(
    "John",
    ReviewDate = "2025-01-10")]
public class ReportGenerator
{
}

Terdapat dua jenis parameter dalam penggunaan tersebut:

"John"
    │
    └── positional parameter
        → constructor

ReviewDate = "2025-01-10"
    │
    └── named parameter
        → property

Dengan desain ini, nama penulis menjadi informasi utama yang diberikan melalui constructor, sedangkan tanggal review menjadi informasi tambahan yang bersifat opsional.