Reflection dan Attribute di C#: typeof, GetType dan Custom Attribute

Reflection memungkinkan program memeriksa tipe saat program berjalan: property apa saja yang dimiliki sebuah class, berapa nilainya, method apa yang ada, attribute apa yang terpasang. Attribute adalah separuh lainnya: penanda deklaratif dalam kurung siku, seperti [Obsolete] atau [JsonPropertyName("id")], yang tidak berarti apa-apa sampai compiler atau kode tertentu membacanya dengan reflection. Serializer, ORM, library validasi, framework testing, dan routing ASP.NET semuanya bekerja dengan cara ini.

Sebagian besar kode aplikasi jarang butuh reflection secara langsung, tetapi memahami cara kerjanya menjelaskan banyak perilaku framework.

Object Type: typeof dan GetType

Semuanya dimulai dari System.Type. Ada dua cara untuk mendapatkannya:

using System;

class Employee { public string Name { get; set; } }
class Manager : Employee { public int Reports { get; set; } }

class Program
{
    static void Main()
    {
        Type t1 = typeof(Employee);          // from a type name, at compile time
        Employee e = new Manager();
        Type t2 = e.GetType();               // from an object, at run time

        Console.WriteLine(t1.Name);
        Console.WriteLine(t2.Name);          // the real type, not the variable's type
        Console.WriteLine(t2.BaseType.Name);

        Console.WriteLine(e.GetType() == typeof(Employee));   // exact type check
        Console.WriteLine(e is Employee);                     // "is it an Employee or derived?"
        Console.WriteLine(typeof(Employee).IsAssignableFrom(t2));

        Console.WriteLine(typeof(int).FullName);
        Console.WriteLine(typeof(string).IsValueType);
        Console.WriteLine(nameof(Employee.Name));             // compile-time name, no reflection
    }
}

Output:

Employee
Manager
Employee
False
True
True
System.Int32
False
Name

Perbedaan yang perlu diingat: typeof(X) menyebut tipe yang sudah kamu ketahui saat menulis kode, sedangkan obj.GetType() menanyakan sebuah object tipe aslinya. Perbandingan GetType() == typeof(Employee) adalah pencocokan persis yang gagal untuk class turunan, dan biasanya bukan itu yang kamu inginkan; is dan IsAssignableFrom memperhitungkan pewarisan. nameof terlihat mirip, tetapi sama sekali bukan reflection: compiler menggantinya dengan konstanta string.

GetType() pada referensi null melempar NullReferenceException, karena tidak ada object yang bisa ditanya. Pada nullable value type yang sudah mengalami boxing, method ini mengembalikan tipe dasarnya: ((int?)5).GetType() adalah System.Int32.

Membaca dan mengisi property

GetProperties() menampilkan property public sebuah tipe sebagai object PropertyInfo, yang masing-masing bisa membaca dan menulis nilai pada instance tertentu:

using System;
using System.Reflection;

class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Stock { get; set; }
    private string supplierCode = "SUP-77";
}

class Program
{
    static void Main()
    {
        var mug = new Product { Name = "Mug", Price = 8.50m, Stock = 12 };
        Type type = mug.GetType();

        foreach (PropertyInfo p in type.GetProperties())
            Console.WriteLine($"{p.Name,-6} {p.PropertyType.Name,-8} = {p.GetValue(mug)}");

        PropertyInfo price = type.GetProperty("Price");
        price.SetValue(mug, 7.90m);
        Console.WriteLine(mug.Price);

        Console.WriteLine(type.GetProperty("Colour") == null);   // no such property

        FieldInfo hidden = type.GetField("supplierCode", BindingFlags.NonPublic | BindingFlags.Instance);
        Console.WriteLine(hidden.GetValue(mug));
    }
}

Output:

Name   String   = Mug
Price  Decimal  = 8.50
Stock  Int32    = 12
7.90
True
SUP-77

Ada tiga hal yang ditunjukkan contoh ini:

• GetValue mengembalikan object, jadi value type kembali dalam bentuk boxed dan kamu perlu melakukan cast untuk memakainya.
• GetProperty dengan nama yang tidak ada mengembalikan null, dan pemanggilan berikutnya padanya melempar NullReferenceException. Periksa sebelum dipakai.
• BindingFlags.NonPublic | BindingFlags.Instance bisa menjangkau member private. Itu sah di tooling dan tes, tetapi melewati enkapsulasi dan rusak diam-diam saat class itu kamu refactor.

Perulangan ini pada dasarnya adalah cara kerja exporter CSV atau serializer object ke JSON: telusuri property-nya, baca setiap nilai, lalu format.

Memanggil method dan membuat object lewat nama

GetMethod mencari sebuah method, dan Invoke memanggilnya dengan array argumen. Activator.CreateInstance membuat object dari sebuah Type, dan begitulah sistem plugin dan container DI membangun tipe yang dipilih saat program berjalan:

using System;
using System.Reflection;

class PriceCalculator
{
    public decimal Rate { get; set; } = 0.20m;
    public decimal WithTax(decimal net) => net * (1 + Rate);
    public string Describe() => $"Tax rate {Rate:P0}";
}

class Program
{
    static void Main()
    {
        Type type = typeof(PriceCalculator);
        object calc = Activator.CreateInstance(type);

        MethodInfo withTax = type.GetMethod("WithTax");
        object result = withTax.Invoke(calc, new object[] { 50m });
        Console.WriteLine(result);

        foreach (MethodInfo m in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
        {
            if (m.IsSpecialName) continue;   // skip property getters and setters
            Console.WriteLine($"{m.ReturnType.Name} {m.Name}({m.GetParameters().Length} parameters)");
        }

        Type byName = Type.GetType("PriceCalculator");
        Console.WriteLine(byName == type);
    }
}

Output:

60.00
Decimal WithTax(1 parameters)
String Describe(0 parameters)
True

DeclaredOnly membatasi daftar hanya pada member yang dideklarasikan di class itu sendiri; tanpanya, GetMethods juga mengembalikan ToString, Equals, GetHashCode, dan GetType dari object. Type.GetType("Name") butuh nama lengkap beserta namespace-nya, dan untuk tipe di assembly lain juga nama assembly-nya ("MyApp.Plugins.Csv, MyApp.Plugins").

Jika method yang dipanggil melempar exception, Invoke membungkusnya dalam TargetInvocationException; exception aslinya ada di InnerException.

Attribute: penanda yang dibaca compiler dan framework

Attribute ditulis dalam kurung siku sebelum hal yang dijelaskannya. Framework mendefinisikan banyak attribute; berikut beberapa yang mengubah apa yang dilakukan compiler:

public class OrderService
{
    [Obsolete("Use PlaceOrderAsync instead.")]
    public void PlaceOrder(Order order) { }
    // Every call site: warning CS0618: 'OrderService.PlaceOrder(Order)' is obsolete: 'Use PlaceOrderAsync instead.'
    // [Obsolete("...", true)] makes it error CS0619 instead.

    [Conditional("DEBUG")]
    public void Trace(string message) => Console.WriteLine(message);
    // Calls to Trace are removed entirely from builds without the DEBUG symbol.
}

[Flags] enum Channels { None = 0, Email = 1, Sms = 2 }   // changes how ToString formats combinations
[Serializable] class Snapshot { }                     // marks a type for legacy binary serialization

Attribute lain dibaca oleh library saat program berjalan: [JsonPropertyName] dan [JsonIgnore] oleh System.Text.Json, [Required] dan [MaxLength] oleh validasi model ASP.NET Core dan Entity Framework, [HttpGet("orders/{id}")] oleh routing ASP.NET, [Fact] dan [Test] oleh test runner. Attribute itu sendiri tidak melakukan apa-apa; kode yang mencarinya yang bekerja.

Nama ObsoleteAttribute disingkat menjadi [Obsolete] saat dipasang: menurut konvensi, setiap nama class attribute diakhiri Attribute, dan C# mengizinkanmu menghilangkan akhiran itu.

Mendeklarasikan dan membaca custom attribute

Custom attribute adalah class yang diturunkan dari Attribute. [AttributeUsage] menyatakan di mana attribute itu boleh dipasang. Parameter constructor menjadi argumen posisional, dan property public yang bisa diisi menjadi argumen bernama:

using System;
using System.Collections.Generic;
using System.Reflection;

[AttributeUsage(AttributeTargets.Property)]
class RequiredAttribute : Attribute { }

[AttributeUsage(AttributeTargets.Property)]
class MaxLengthAttribute : Attribute
{
    public int Length { get; }
    public string Message { get; set; }            // optional, set as a named argument
    public MaxLengthAttribute(int length) { Length = length; }
}

class SignupForm
{
    [Required, MaxLength(20)]
    public string Username { get; set; }

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

    [MaxLength(10, Message = "Keep the city code short")]
    public string CityCode { get; set; }
}

static class Validator
{
    public static List<string> Validate(object model)
    {
        var errors = new List<string>();
        foreach (PropertyInfo p in model.GetType().GetProperties())
        {
            var value = p.GetValue(model) as string;

            if (p.GetCustomAttribute<RequiredAttribute>() != null && string.IsNullOrWhiteSpace(value))
                errors.Add($"{p.Name} is required");

            var max = p.GetCustomAttribute<MaxLengthAttribute>();
            if (max != null && value != null && value.Length > max.Length)
                errors.Add(max.Message ?? $"{p.Name} must be at most {max.Length} characters");
        }
        return errors;
    }
}

class Program
{
    static void Main()
    {
        var form = new SignupForm { Username = "a_very_long_username_indeed", CityCode = "LISBON-CENTRAL" };
        foreach (var error in Validator.Validate(form))
            Console.WriteLine(error);

        var ok = new SignupForm { Username = "ana", Email = "ana@example.com", CityCode = "LIS" };
        Console.WriteLine(Validator.Validate(ok).Count);
    }
}

Output:

Username must be at most 20 characters
Email is required
Keep the city code short
0

Itu adalah versi mini dari apa yang dilakukan validasi model ASP.NET Core dengan System.ComponentModel.DataAnnotations. Argumen attribute harus berupa konstanta saat kompilasi (angka, string, typeof(...), nilai enum, atau array dari semua itu), karena argumen tersebut disimpan di metadata assembly. GetCustomAttribute<T>() adalah extension method di System.Reflection; ada juga IsDefined(typeof(T)) jika kamu hanya perlu tahu apakah sebuah attribute terpasang.

Biaya reflection

Reflection menukar kecepatan dan keamanan dengan fleksibilitas:

• Kecepatan. Mencari member lewat namanya lalu memanggilnya lewat Invoke atau GetValue jauh lebih lambat daripada pemanggilan langsung, dan value type ikut mengalami boxing. Untuk pemakaian berulang, cari PropertyInfo atau MethodInfo sekali lalu simpan, atau ubah menjadi delegate dengan Delegate.CreateDelegate atau MethodInfo.CreateDelegate lalu panggil delegate itu.
• Keamanan. Nama yang salah ketik atau signature yang berubah tetap bisa dikompilasi, lalu gagal saat program berjalan. Sebisa mungkin, pakai nameof(Product.Price) alih-alih string "Price", agar penggantian nama ketahuan.
• Trimming dan AOT. Aplikasi dengan trimming dan Native AOT menghapus member yang terlihat tidak dipakai, dan reflection menyembunyikan pemakaian itu dari analisisnya. Library modern (System.Text.Json, GeneratedRegex, logging) mulai beralih ke source generator, yang melakukan pekerjaan yang sama saat kompilasi.

Pakai reflection untuk bagian program yang memang tidak tahu tipenya sejak awal: plugin, tooling generic, serializer, helper untuk tes. Jika tipenya sudah diketahui, kode biasa, generic, atau interface lebih cepat dan diperiksa oleh compiler.

Kesalahan umum

• GetType() == typeof(Base) untuk menguji base class. Cara ini gagal untuk tipe turunan. Pakai is atau IsAssignableFrom.
• Tidak memeriksa null. GetProperty, GetMethod, dan Type.GetType mengembalikan null jika tidak ada yang cocok.
• Reflection di dalam perulangan yang sering dijalankan tanpa cache. Simpan MemberInfo di cache atau compile sebuah delegate.
• Menangkap exception yang salah dari Invoke. Exception aslinya adalah InnerException dari TargetInvocationException.
• String ajaib untuk nama member. Pakai nameof.