C#
Reflection and attributes
Write command handling with reflection and custom attributes.
Reflection and attributes
In the second lesson the command stood alone. Now we mark commands with an attribute and discover them through reflection. The [Command("hello")] attribute gives a class a name; Assembly.GetExecutingAssembly().GetTypes() enumerates all types; t.GetCustomAttribute<CommandAttribute>() reads the attribute.
Result: to add a new command you only write a new class marked with [Command("name")]. Main does not change; reflection finds the command automatically. This is a strong application of the open-closed principle.
The command attribute
The CommandAttribute class derives from Attribute and carries a Name property. Usage: [Command("hello")]. The value in parentheses is passed to the constructor. The attribute adds compile-time metadata to the class; it is read at runtime via reflection.
Note: with AttributeUsage you can restrict the attribute to classes only. For now the default usage is enough; you can add this restriction later.
Exercise Discover commands via reflection
Define a CommandAttribute : Attribute class; its constructor takes a string name and assigns it to a Name property. Mark HelloCommand with [Command("hello")]. In Main, scan all types via Assembly.GetExecutingAssembly().GetTypes(); for each type call t.GetCustomAttribute<CommandAttribute>(). Add types that have the attribute and implement ICommand to a Dictionary<string, Type>. Get the type with commands["hello"], instantiate it with Activator.CreateInstance, cast to (ICommand), and print await cmd.ExecuteAsync().
Show example solution
Attribute { public string Name { get; } public CommandAttribute(string name) => Name = name; }. Mark HelloCommand with [Command("hello")]. In Main: var commands = new Dictionary<string, Type>(); foreach (var t in Assembly.GetExecutingAssembly().GetTypes()) { var attr = t.GetCustomAttribute<CommandAttribute>(); if (attr != null && typeof(ICommand).IsAssignableFrom(t)) commands[attr.Name] = t; } var type = commands["hello"]; var cmd = (ICommand)Activator.CreateInstance(type); Console.WriteLine(await cmd.ExecuteAsync());
Example solution:
using System;
using System.Threading.Tasks;
using System.Reflection;
using System.Collections.Generic;
[Command("hello")]
class HelloCommand : ICommand
{
public async Task<string> ExecuteAsync()
{
await Task.CompletedTask;
return "Merhaba";
}
}
class CommandAttribute : Attribute
{
public string Name { get; }
public CommandAttribute(string name) => Name = name;
}
interface ICommand
{
Task<string> ExecuteAsync();
}
class Program
{
static async Task Main()
{
var commands = new Dictionary<string, Type>();
foreach (var t in Assembly.GetExecutingAssembly().GetTypes())
{
var attr = t.GetCustomAttribute<CommandAttribute>();
if (attr != null && typeof(ICommand).IsAssignableFrom(t))
commands[attr.Name] = t;
}
var type = commands["hello"];
var cmd = (ICommand)Activator.CreateInstance(type);
Console.WriteLine(await cmd.ExecuteAsync());
}
}
Test yourself
-
Match reflection terms
- [Command("hello")]
- Marks a class with a name
- GetTypes()
- Enumerates all types
- GetCustomAttribute<T>
- Reads the attribute
- Activator.CreateInstance
- Instantiates a type
-
Complete the attribute usage
[Command("____")]
class HelloCommand : ICommand { ... }
Show answer
[Command("hello")]
class HelloCommand : ICommand { ... }
-
What does reflection-based command discovery add?
- Faster execution
- Less code overall
- Static type safety
- Adding a new command does not change Main
Show answer
Adding a new command does not change Main — Correct. Reflection finds the new command automatically; Main stays the same.
Next lesson: DI and tests
