【C#】属性（Attribute）完全ガイド｜AttributeUsage・組み込み属性・CallerInfo・DataAnnotations・リフレクションまで

// 属性は [AttributeName(引数)] の形で要素に付与する
// 末尾の "Attribute" は省略可能 → [Obsolete] と [ObsoleteAttribute] は同じ

[Obsolete("v2.0 以降は NewMethod() を使ってください")]
public static void OldMethod() { }

[Obsolete("使用禁止", error: true)] // error=true にするとコンパイルエラー
public static void BannedMethod() { }

// 複数の属性を付与する（2通りの書き方）
[Serializable]
[Obsolete("v3 で削除予定")]
public class LegacyData { }

// または一つの [...] にまとめる
[Serializable, Obsolete("v3 で削除予定")]
public class LegacyData2 { }

// メソッド・プロパティ・フィールド・パラメーター・戻り値など様々な要素に付与できる
public class Example
{
    [DebuggerDisplay("Name={Name}, Age={Age}")]
    public record Person(string Name, int Age);

    [return: MarshalAs(UnmanagedType.Bool)] // 戻り値に付与
    public static extern bool NativeFunc();
}

// AttributeUsage の3パラメーター
// ① ValidOn: 適用対象（AttributeTargets 列挙体）
// ② AllowMultiple: 同じ要素に複数回付けられるか（デフォルト: false）
// ③ Inherited: サブクラスや override メソッドに継承されるか（デフォルト: true）

[AttributeUsage(
    AttributeTargets.Class | AttributeTargets.Method,
    AllowMultiple = false,
    Inherited     = true)]
public class AuthorAttribute : Attribute
{
    public string Name    { get; }
    public string Version { get; set; } = "1.0"; // named parameter（省略可能）

    public AuthorAttribute(string name) => Name = name; // positional parameter（必須）
}

// 使い方
[Author("Alice")]
[Author("Bob")]   // NG: AllowMultiple=false なのでコンパイルエラー
public class MyClass { }

// AllowMultiple = true: 同じ要素に複数回付けられる
[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
public class TagAttribute : Attribute
{
    public string Value { get; }
    public TagAttribute(string value) => Value = value;
}

[Tag("performance")]
[Tag("experimental")]
[Tag("internal")]
public void ProcessData() { }
// → GetCustomAttributes で3つ取得できる

// Inherited = false: サブクラスには継承されない
[AttributeUsage(AttributeTargets.Class, Inherited = false)]
public class SealedMarkerAttribute : Attribute { }

[SealedMarker]
public class Base { }

public class Derived : Base { }
// → typeof(Derived).GetCustomAttribute<SealedMarkerAttribute>() は null を返す
// → typeof(Base).GetCustomAttribute<SealedMarkerAttribute>() は値を返す

// Inherited = true（デフォルト）+ virtual メソッドの場合
[AttributeUsage(AttributeTargets.Method, Inherited = true)]
public class LogAttribute : Attribute { }

public class ServiceBase
{
    [Log]
    public virtual void Execute() { }
}

public class ServiceImpl : ServiceBase
{
    public override void Execute() { } // [Log] は継承される
}
// → typeof(ServiceImpl).GetMethod("Execute")!.GetCustomAttribute<LogAttribute>()
//   → LogAttribute オブジェクトが返る（Inherited=true のため）

// 警告のみ（デフォルト）
[Obsolete("NewCalculate() を使ってください")]
public int OldCalculate(int x) => x * 2;

// エラーとして扱う（コンパイル不可にする）
[Obsolete("このメソッドは削除されました", error: true)]
public void DeletedMethod() { }

// DiagnosticId と UrlFormat（C# 10 / .NET 5+）
[Obsolete("新APIを使用してください", DiagnosticId = "MY001",
          UrlFormat = "https://docs.example.com/migration/{0}")]
public void ObsoleteWithDocs() { }

using System.Diagnostics;

// DEBUG シンボルが定義されているときのみ呼び出しがコンパイルされる
// → Release ビルドではメソッド呼び出し自体がコードから消える（引数も評価されない）
[Conditional("DEBUG")]
static void LogDebug(string message)
{
    Console.WriteLine($"[DEBUG] {message}");
}

// TRACE シンボルでも使える
[Conditional("TRACE")]
static void LogTrace(string message) { /* ... */ }

// 複数の Conditional: いずれかのシンボルが定義されていれば有効
[Conditional("DEBUG")]
[Conditional("TESTING")]
static void InternalAssert(bool condition) { /* ... */ }

using System.Diagnostics;

// デバッガーのウォッチ/ローカル変数ウィンドウでの表示形式を指定
[DebuggerDisplay("Id={Id}, Name={Name}, Active={IsActive}")]
public class User
{
    public int    Id       { get; set; }
    public string Name     { get; set; } = "";
    public bool   IsActive { get; set; }
}
// デバッガーで User オブジェクトを確認すると "Id=1, Name=Alice, Active=True" と表示される

// DebuggerBrowsable: デバッガーでのプロパティの展開方法を制御
public class BinaryTree<T>
{
    [DebuggerBrowsable(DebuggerBrowsableState.Never)] // デバッガーに表示しない
    private Node? _root;

    [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)] // ルートを隠して子要素を直接展開
    private T[] DebugItems => ToArray();
}

// DebuggerStepThrough: デバッガーのステップ実行でスキップ（プロパティアクセサーなど）
[DebuggerStepThrough]
public string GetFormattedName() => $"{FirstName} {LastName}";

// [Flags] を付けると ToString() がビット単位の名前列挙になり、
// ビット演算（|, &, ^, ~）を組み合わせて使うことが想定されたことを示す
[Flags]
public enum Permissions
{
    None    = 0,
    Read    = 1,      // 0001
    Write   = 2,      // 0010
    Execute = 4,      // 0100
    Delete  = 8,      // 1000
    All     = Read | Write | Execute | Delete  // 1111
}

var p = Permissions.Read | Permissions.Write;
Console.WriteLine(p);                         // "Read, Write"（[Flags] なし: "3"）
Console.WriteLine(p.HasFlag(Permissions.Read));  // True
Console.WriteLine(p.HasFlag(Permissions.Delete)); // False

// ビット演算でフラグを追加/削除
p |= Permissions.Execute;  // Execute を追加
p &= ~Permissions.Write;   // Write を削除
Console.WriteLine(p);      // "Read, Execute"

using System.Runtime.InteropServices;

// Sequential: フィールドを宣言順に配置（デフォルト、P/Invoke で使う）
[StructLayout(LayoutKind.Sequential)]
public struct Point
{
    public int X;
    public int Y;
}

// Explicit: 各フィールドのバイトオフセットを手動指定（Union 相当）
[StructLayout(LayoutKind.Explicit, Size = 4)]
public struct IntAndBytes
{
    [FieldOffset(0)] public int   IntValue;   // 4バイト
    [FieldOffset(0)] public byte  Byte0;      // 同じアドレスを共有（C の union）
    [FieldOffset(1)] public byte  Byte1;
    [FieldOffset(2)] public byte  Byte2;
    [FieldOffset(3)] public byte  Byte3;
}

// int の各バイトを分解する
var u = new IntAndBytes { IntValue = 0x01020304 };
Console.WriteLine(u.Byte3); // 0x01（ビッグエンディアン環境では逆）

using System.Runtime.InteropServices;

public static class NativeMethods
{
    // Windows API の MessageBox を呼び出す
    [DllImport("user32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    public static extern int MessageBox(
        IntPtr hWnd,
        string lpText,
        string lpCaption,
        uint uType);

    // Linux/macOS では libc の関数を呼ぶ
    [DllImport("libc", EntryPoint = "printf")]
    public static extern int Printf(string format, int value);

    // .NET 7+ では LibraryImport が推奨（ソースジェネレーターで型安全）
    // [LibraryImport("user32.dll")]
    // public static partial int MessageBoxW(...);
}

// 使い方
NativeMethods.MessageBox(IntPtr.Zero, "Hello from C#!", "Info", 0);

using System.Runtime.CompilerServices;

// ログ用ヘルパー: 呼び出し元情報を自動取得
static void Log(
    string message,
    [CallerMemberName] string memberName  = "",
    [CallerLineNumber] int    lineNumber  = 0,
    [CallerFilePath]   string sourceFile  = "")
{
    Console.WriteLine($"[{Path.GetFileName(sourceFile)}:{lineNumber}] {memberName}() - {message}");
}

// 呼び出し側: 引数を省略するだけでコンパイラが埋め込む
static void ProcessOrder(int id)
{
    Log("処理開始");
    // → "[Program.cs:25] ProcessOrder() - 処理開始" のように出力される
}

// INotifyPropertyChanged の実装を簡潔に書く
public class ViewModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler? PropertyChanged;

    private string _name = "";
    public string Name
    {
        get => _name;
        set
        {
            if (_name != value)
            {
                _name = value;
                OnPropertyChanged(); // 引数不要: 自動的に "Name" が渡される
            }
        }
    }

    protected void OnPropertyChanged([CallerMemberName] string propertyName = "")
        => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}

// C# 10 以降: 引数として渡された式そのものの文字列を取得できる
// → アサーションライブラリで値と式名を同時に表示するのに便利
static void Assert(
    bool condition,
    [CallerArgumentExpression("condition")] string? conditionExpr = null,
    [CallerMemberName] string memberName = "",
    [CallerLineNumber] int lineNumber = 0)
{
    if (!condition)
        throw new AssertionException(
            $"Assertion failed at {memberName}:{lineNumber}
  Expression: {conditionExpr}");
}

// 使い方
int x = 5;
Assert(x > 10);
// 例外メッセージ: "Assertion failed at Main:xx
  Expression: x > 10"
// → 式名 "x > 10" がそのまま取れる（従来は nameof が使えず手書きが必要だった）

// .NET 6+ の ArgumentNullException.ThrowIfNull もこれを内部で使用している
static void ThrowIfNull(
    object? argument,
    [CallerArgumentExpression("argument")] string? paramName = null)
{
    if (argument is null)
        throw new ArgumentNullException(paramName);
}

// 属性のコンストラクター/プロパティに使える型は制限されている:
// - プリミティブ型 (bool, byte, char, short, int, long, float, double)
// - string
// - Type
// - Enum 型
// - object（実際には上記の型の値を渡す）
// - 上記の 1 次元配列

[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
public class ValidationAttribute : Attribute
{
    // OK: int, string, Type, bool
    public int    MinLength { get; set; }
    public int    MaxLength { get; set; }
    public string? Pattern  { get; set; }
    public Type?  ValidatorType { get; set; }
    public bool   IsRequired { get; set; }

    // OK: 配列
    public string[] AllowedValues { get; set; } = Array.Empty<string>();
}

// 使い方: 定数式のみ（変数や new は使えない）
public class Product
{
    [Validation(MinLength = 1, MaxLength = 100, IsRequired = true)]
    public string Name { get; set; } = "";

    [Validation(ValidatorType = typeof(PriceValidator))]
    public decimal Price { get; set; }

    // NG: 変数は使えない
    // const int MAX = 100; → const は OK
    // int max = 100;        → NG: コンパイルエラー
}

// 規約: 属性クラス名は "Attribute" で終わる
// → [Author] と書いたとき、コンパイラは AuthorAttribute を探す
// → Author と AuthorAttribute の両方を定義すると曖昧さがありエラーになる

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public sealed class AuthorAttribute : Attribute  // sealed を付けることが多い
{
    // positional parameter（コンストラクター引数）: 必須
    public string Name { get; }

    // named parameter（プロパティ）: 省略可能
    public string Email { get; set; } = "";
    public int    Since { get; set; }

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

// 使い方: positional は順番通り、named は名前指定
[Author("Alice", Email = "alice@example.com", Since = 2020)]
public class DataProcessor { }

// sealed を付ける理由:
// 属性クラスを継承すると Inherited=true の挙動が複雑になりやすい
// → ほとんどのカスタム属性は sealed にするのが推奨

using System.Reflection;

[Author("Alice", Email = "alice@example.com")]
public class UserService
{
    [Author("Bob")]
    [Tag("public-api")]
    [Tag("v2")]
    public void GetUser(int id) { }
}

// ① 単一の属性を取得（ない場合は null）
var type = typeof(UserService);
AuthorAttribute? classAuthor = type.GetCustomAttribute<AuthorAttribute>();
Console.WriteLine(classAuthor?.Name);   // "Alice"
Console.WriteLine(classAuthor?.Email);  // "alice@example.com"

// ② inherit フラグ: サブクラスを含む継承チェーンも検索するか
AuthorAttribute? inherited = type.GetCustomAttribute<AuthorAttribute>(inherit: true);

// ③ 複数の属性を取得（AllowMultiple=true の属性）
var method = type.GetMethod(nameof(UserService.GetUser))!;
IEnumerable<TagAttribute> tags = method.GetCustomAttributes<TagAttribute>();
foreach (var tag in tags)
    Console.WriteLine(tag.Value); // "public-api", "v2"

// ④ 存在確認のみ（属性インスタンスが不要な場合）
bool hasLog = method.IsDefined(typeof(LogAttribute), inherit: false);

// ⑤ 型情報を持つ CustomAttributeData（属性インスタンスを生成せずに情報取得）
var attrData = type.GetCustomAttributesData();
foreach (var data in attrData)
{
    Console.WriteLine($"属性型: {data.AttributeType.Name}");
    foreach (var arg in data.ConstructorArguments)
        Console.WriteLine($"  引数: {arg.Value}");
    foreach (var named in data.NamedArguments)
        Console.WriteLine($"  {named.MemberName} = {named.TypedValue.Value}");
}

using System.Reflection;

// クラス / 構造体 / インターフェイス
Type t = typeof(MyClass);
var classAttrs = t.GetCustomAttributes<MyAttribute>();

// メソッド
MethodInfo method = t.GetMethod("MethodName")!;
var methodAttrs = method.GetCustomAttributes<MyAttribute>();

// プロパティ
PropertyInfo prop = t.GetProperty("PropName")!;
var propAttrs = prop.GetCustomAttributes<MyAttribute>();

// フィールド
FieldInfo field = t.GetField("_fieldName",
    BindingFlags.Instance | BindingFlags.NonPublic)!;
var fieldAttrs = field.GetCustomAttributes<MyAttribute>();

// コンストラクター
ConstructorInfo ctor = t.GetConstructor(new[] { typeof(int) })!;
var ctorAttrs = ctor.GetCustomAttributes<MyAttribute>();

// メソッドのパラメーター
ParameterInfo[] parameters = method.GetParameters();
var paramAttrs = parameters[0].GetCustomAttributes<MyAttribute>();

// メソッドの戻り値
ParameterInfo returnParam = method.ReturnParameter;
var returnAttrs = returnParam.GetCustomAttributes<MyAttribute>();

// アセンブリ
Assembly asm = Assembly.GetExecutingAssembly();
var asmAttrs = asm.GetCustomAttributes<AssemblyVersionAttribute>();
Console.WriteLine(asmAttrs.FirstOrDefault()?.Version);

// パターン: 型ごとに属性をキャッシュして毎回リフレクションしない
public static class AttributeCache<TAttr> where TAttr : Attribute
{
    private static readonly Dictionary<MemberInfo, TAttr?> _cache = new();
    private static readonly object _lock = new();

    public static TAttr? Get(MemberInfo member)
    {
        lock (_lock)
        {
            if (!_cache.TryGetValue(member, out var attr))
            {
                attr = member.GetCustomAttribute<TAttr>();
                _cache[member] = attr;
            }
            return attr;
        }
    }
}

// 使い方
var attr = AttributeCache<AuthorAttribute>.Get(typeof(UserService));

using System.ComponentModel.DataAnnotations;

public class RegisterRequest
{
    [Required(ErrorMessage = "ユーザー名は必須です")]
    [StringLength(50, MinimumLength = 3, ErrorMessage = "3〜50文字で入力してください")]
    [RegularExpression(@"^[a-zA-Z0-9_]+$", ErrorMessage = "英数字とアンダースコアのみ使用できます")]
    public string Username { get; set; } = "";

    [Required]
    [EmailAddress(ErrorMessage = "正しいメールアドレス形式で入力してください")]
    public string Email { get; set; } = "";

    [Required]
    [StringLength(100, MinimumLength = 8)]
    [DataType(DataType.Password)]
    public string Password { get; set; } = "";

    [Compare("Password", ErrorMessage = "パスワードが一致しません")]
    [DataType(DataType.Password)]
    public string ConfirmPassword { get; set; } = "";

    [Range(0, 150, ErrorMessage = "0〜150の値を入力してください")]
    public int Age { get; set; }
}

// 手動バリデーション（ASP.NET Core 以外の環境でも使える）
var request = new RegisterRequest
{
    Username = "al",  // 短すぎる
    Email    = "invalid-email",
    Password = "pass",
};

var context = new ValidationContext(request);
var results  = new List<ValidationResult>();
bool isValid = Validator.TryValidateObject(request, context, results, validateAllProperties: true);

if (!isValid)
{
    foreach (var result in results)
        Console.WriteLine($"- {result.ErrorMessage}");
    // - 3〜50文字で入力してください
    // - 正しいメールアドレス形式で入力してください
    // - (パスワードのエラー)
}

// ValidationAttribute を継承してカスタムバリデーターを作る
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
public sealed class ZipCodeAttribute : ValidationAttribute
{
    // 日本の郵便番号（ハイフンあり/なし両対応）: ^[0-9]{3}-?[0-9]{4}$
    private static readonly System.Text.RegularExpressions.Regex Pattern =
        new(@"^[0-9]{3}-?[0-9]{4}$", System.Text.RegularExpressions.RegexOptions.Compiled);

    protected override ValidationResult? IsValid(object? value, ValidationContext ctx)
    {
        if (value is null) return ValidationResult.Success; // null は [Required] に委ねる

        string str = value.ToString()!;
        if (Pattern.IsMatch(str))
            return ValidationResult.Success;

        // エラーメッセージに表示名（DisplayName）を含める
        return new ValidationResult(
            $"{ctx.DisplayName} は正しい郵便番号形式（例: 123-4567）で入力してください",
            new[] { ctx.MemberName! });
    }
}

// 使い方
public class Address
{
    [Display(Name = "郵便番号")]
    [ZipCode]
    public string ZipCode { get; set; } = "";
}

using System.Text.Json;
using System.Text.Json.Serialization;

public class ApiResponse
{
    [JsonPropertyName("user_id")]          // JSON では "user_id" として出力
    public int UserId { get; set; }

    [JsonPropertyName("full_name")]
    public string FullName { get; set; } = "";

    [JsonIgnore]                           // シリアライズ対象外
    public string InternalSecret { get; set; } = "";

    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    public string? OptionalNote { get; set; } // null のとき出力しない

    [JsonConverter(typeof(DateTimeOffsetConverter))]
    public DateTimeOffset CreatedAt { get; set; }

    [JsonExtensionData]                    // 未知のプロパティを受け取る
    public Dictionary<string, JsonElement>? ExtraProperties { get; set; }
}

// シリアライズ
var response = new ApiResponse
{
    UserId   = 1,
    FullName = "Alice",
    InternalSecret = "secret",  // 出力されない
};
string json = JsonSerializer.Serialize(response);
// → {"user_id":1,"full_name":"Alice","created_at":"..."}

// カスタムコンバーター
public class DateTimeOffsetConverter : JsonConverter<DateTimeOffset>
{
    public override DateTimeOffset Read(
        ref Utf8JsonReader reader, Type type, JsonSerializerOptions options)
        => DateTimeOffset.Parse(reader.GetString()!);

    public override void Write(
        Utf8JsonWriter writer, DateTimeOffset value, JsonSerializerOptions options)
        => writer.WriteStringValue(value.ToString("yyyy-MM-ddTHH:mm:sszzz"));
}

// 属性でバリデーション条件を宣言し、呼び出し前に自動チェックするパターン
[AttributeUsage(AttributeTargets.Parameter)]
public sealed class NotNullOrEmptyAttribute : Attribute { }

[AttributeUsage(AttributeTargets.Parameter)]
public sealed class PositiveAttribute : Attribute { }

// リフレクションでパラメーター属性を確認するバリデーター
public static class ParameterValidator
{
    public static void Validate(object?[] args, System.Reflection.ParameterInfo[] parameters)
    {
        for (int i = 0; i < parameters.Length; i++)
        {
            var param = parameters[i];
            var value = args[i];

            if (param.IsDefined(typeof(NotNullOrEmptyAttribute)) &&
                value is string s && string.IsNullOrEmpty(s))
            {
                throw new ArgumentException(
                    $"パラメーター '{param.Name}' は空にできません");
            }

            if (param.IsDefined(typeof(PositiveAttribute)) &&
                value is int n && n <= 0)
            {
                throw new ArgumentOutOfRangeException(
                    param.Name, $"'{param.Name}' は正の整数である必要があります");
            }
        }
    }
}

// メソッドに必要な権限を宣言する属性
[AttributeUsage(AttributeTargets.Method)]
public sealed class RequiresRoleAttribute : Attribute
{
    public string[] Roles { get; }
    public RequiresRoleAttribute(params string[] roles) => Roles = roles;
}

// サービスクラス
public class OrderService
{
    [RequiresRole("Admin", "Manager")]
    public void DeleteOrder(int orderId) { /* ... */ }

    [RequiresRole("User")]
    public Order GetOrder(int orderId) => throw new NotImplementedException();
}

// チェックロジック（ディスパッチャーや DI でラップして使う）
static void CheckPermissions(object service, string methodName, string currentUserRole)
{
    var method = service.GetType().GetMethod(methodName)!;
    var attr   = method.GetCustomAttribute<RequiresRoleAttribute>();

    if (attr != null && !attr.Roles.Contains(currentUserRole))
        throw new UnauthorizedAccessException(
            $"{methodName} には {string.Join("/", attr.Roles)} ロールが必要です");
}

// 実際のアプリケーションでは Castle.DynamicProxy / DispatchProxy などの
// インターセプターと組み合わせて完全な AOP を実現する