Reflection in C# :👈 👉:Threading in C#

🏷️ Attributes in C#

🏷️ Attributes in C#

Attributes in C# are declarative tags used to add metadata to code elements like classes, methods, properties, and assemblies. They influence runtime behavior, tooling, and compilation without changing the actual logic.

📘 Syntax Example


  [Obsolete("Use NewMethod instead")]
  public void OldMethod() {
      Console.WriteLine("This method is obsolete.");
  }
  

📚 Types of Attributes

  • Predefined Attributes: Built into .NET (e.g., Obsolete, Serializable, DllImport).
  • Custom Attributes: User-defined by inheriting from System.Attribute.
  • Assembly-Level Attributes: Apply to the entire assembly (e.g., [assembly: CLSCompliant(true)]).

🧪 Custom Attribute Example


  [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
  public class DeveloperInfoAttribute : Attribute {
      public string DeveloperName { get; }
      public string Version { get; }

      public DeveloperInfoAttribute(string name, string version) {
          DeveloperName = name;
          Version = version;
      }
  }

  [DeveloperInfo("Shivshanker", "1.0")]
  public class MyClass {
      public void Display() => Console.WriteLine("Hello from MyClass");
  }
  

🔍 Reading Attributes via Reflection


  var type = typeof(MyClass);
  var attr = type.GetCustomAttribute<DeveloperInfoAttribute>();
  Console.WriteLine($"Developer: {attr.DeveloperName}, Version: {attr.Version}");
  

✅ Best Practices

  • Use attributes to annotate behavior, not to implement logic.
  • Use AttributeUsage to control where your custom attribute can be applied.
  • Keep attribute constructors simple and use named parameters for optional data.
  • Use reflection responsibly—cache results if performance matters.

📌 When to Use

  • To mark obsolete code or provide versioning info.
  • To control serialization, validation, or interop behavior.
  • In frameworks and libraries to enable extensibility.
  • For runtime metadata inspection (e.g., unit testing, logging).

🚫 When Not to Use

  • To replace business logic—attributes are metadata, not behavior.
  • In performance-critical paths—reflection can be slow.
  • For dynamic behavior without proper validation or fallback.

⚠️ Precautions

  • Avoid overusing attributes—they can clutter code and reduce readability.
  • Use reflection carefully—handle missing attributes gracefully.
  • Ensure attribute data is immutable and thread-safe.

🎯 Advantages

  • Declarative: Cleanly separates metadata from logic.
  • Extensible: Enables custom tooling and frameworks.
  • Flexible: Works across assemblies, types, and members.
  • Powerful: Enables runtime inspection and dynamic behavior.

📝 Conclusion

Attributes in C# are a powerful way to enrich your code with metadata. Whether you're marking obsolete methods, customizing serialization, or building extensible frameworks, attributes help you write cleaner, smarter, and more maintainable code.

🔙
Reflection in C# :👈 👉:Threading in C#